@sjawhar/pi-envoy 9.7.0 → 10.0.0

package/dist/dispatch.js

@@ -14958,150 +14958,6 @@ function commandsHelp() {
 `);
 }
 
-// ../envoy-client/src/dispatch-config.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { homedir } from "os";
-import * as path from "path";
-
-// ../envoy-client/src/secret-file.ts
-import { readFileSync } from "fs";
-function readSecretFile(variable, filePath) {
-  let contents;
-  try {
-    contents = readFileSync(filePath, "utf8");
-  } catch (error48) {
-    throw new Error(`${variable} names ${filePath}, which could not be read: ${messageFor(error48)}`);
-  }
-  const value = contents.trim();
-  if (value.length === 0)
-    throw new Error(`${variable} names ${filePath}, which is empty`);
-  return value;
-}
-
-// ../envoy-client/src/dispatch-config.ts
-var DEFAULT_SERVER_URL = "http://localhost:8766";
-function normalizeDispatchUrl(url2) {
-  return url2.replace(/\/+$/, "");
-}
-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` };
-  }
-}
-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()
-});
-function describeSchemaIssue(filePath, error48) {
-  const issue2 = error48.issues[0];
-  if (!issue2)
-    return `${filePath}: invalid dispatch config`;
-  if (issue2.code === "unrecognized_keys") {
-    const keys = issue2.keys.map((key) => `dispatch.${key}`).join(", ");
-    return `${filePath}: unrecognized dispatch key(s): ${keys}`;
-  }
-  return `${filePath}: ${issue2.path.join(".")}: ${issue2.message}`;
-}
-function readEnvoyFile(filePath) {
-  let raw;
-  try {
-    raw = readFileSync2(filePath, "utf-8");
-  } catch {
-    return { kind: "absent" };
-  }
-  let parsedJson;
-  try {
-    parsedJson = JSON.parse(raw);
-  } catch (err) {
-    return { kind: "invalid", reason: `${filePath}: invalid JSON (${messageFor(err)})` };
-  }
-  const parsed = EnvoyFileSchema.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 {
-        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"
-      };
-    }
-    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 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 };
-  let token;
-  let tokenSource;
-  if (env.DISPATCH_TOKEN_FILE !== undefined) {
-    tokenSource = "DISPATCH_TOKEN_FILE";
-    try {
-      token = readSecretFile(tokenSource, env.DISPATCH_TOKEN_FILE);
-    } catch (error48) {
-      return { enabled: false, url: url2.url, token: null, error: 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 };
-}
-function activeDispatchConfig(env, options = {}) {
-  const config2 = resolveDispatchConfig(env, options);
-  if (config2.error !== null)
-    throw new Error(`dispatch config: ${config2.error}`);
-  const { url: url2, token } = config2;
-  if (!config2.enabled || url2 === null || token === null)
-    return null;
-  return { ...config2, url: url2, token };
-}
-
 // ../envoy-client/src/dispatch-execute.ts
 import { resolve as resolvePath2 } from "path";
 
@@ -15337,13 +15193,13 @@ class DispatchClient {
     return this.#resolveIssue(issueReference);
   }
   async listIssuePage(options, page) {
-    const path2 = ["api", "v1", "issues"];
+    const path = ["api", "v1", "issues"];
     const query = { ...options, limit: page.limit, offset: page.offset };
-    const answer = await this.#json("GET", path2, undefined, query);
+    const answer = await this.#json("GET", path, undefined, query);
     const refusal = whyNotAPage(answer);
     if (refusal === undefined)
       return answer;
-    throw new Error(`GET ${this.#url(path2, query)} asked for a page ({issues, total, limit, offset}) and got ` + refusal);
+    throw new Error(`GET ${this.#url(path, query)} asked for a page ({issues, total, limit, offset}) and got ` + refusal);
   }
   async listProjectArtifacts(project, unlinked = false) {
     return this.#json("GET", ["api", "v1", "projects", project, "artifacts"], undefined, unlinked ? { unlinked: "true" } : undefined);
@@ -15584,17 +15440,17 @@ class DispatchClient {
       throw error48;
     }
   }
-  async#json(method, path2, body, query) {
-    return (await this.#jsonAnswer(method, path2, body, query)).payload;
+  async#json(method, path, body, query) {
+    return (await this.#jsonAnswer(method, path, body, query)).payload;
   }
-  async#jsonAnswer(method, path2, body, query) {
+  async#jsonAnswer(method, path, body, query) {
     const headers = {
       Accept: "application/json",
       Authorization: `Bearer ${this.token}`
     };
     if (body !== undefined)
       headers["Content-Type"] = "application/json";
-    const url2 = this.#url(path2, query);
+    const url2 = this.#url(path, query);
     const response = await this.fetchImpl(url2, {
       method,
       headers,
@@ -15603,9 +15459,9 @@ class DispatchClient {
     });
     return { status: response.status, payload: await this.#response(method, url2, response) };
   }
-  async#upload(path2, input) {
+  async#upload(path, input) {
     if ("content" in input)
-      return this.#json("POST", path2, input);
+      return this.#json("POST", path, input);
     const form = new FormData;
     form.set("name", input.name);
     if (input.summary !== undefined)
@@ -15613,10 +15469,10 @@ class DispatchClient {
     if (input.actor !== undefined)
       form.set("actor", JSON.stringify(input.actor));
     form.set("file", input.file, input.name);
-    return this.#form("POST", path2, form);
+    return this.#form("POST", path, form);
   }
-  async#form(method, path2, body) {
-    const url2 = this.#url(path2);
+  async#form(method, path, body) {
+    const url2 = this.#url(path);
     const response = await this.fetchImpl(url2, {
       method,
       headers: { Accept: "application/json", Authorization: `Bearer ${this.token}` },
@@ -15625,8 +15481,8 @@ class DispatchClient {
     });
     return this.#response(method, url2, response);
   }
-  #url(path2, query) {
-    const url2 = new URL(`${path2.map((segment) => encodeURIComponent(segment)).join("/")}`, `${this.#baseUrl}/`);
+  #url(path, query) {
+    const url2 = new URL(`${path.map((segment) => encodeURIComponent(segment)).join("/")}`, `${this.#baseUrl}/`);
     if (query) {
       for (const [name, value] of Object.entries(query)) {
         if (typeof value === "string" || typeof value === "number") {
@@ -15852,9 +15708,9 @@ function shapeOf(schema) {
   const def = unwrapped.def;
   return def.type === "object" && "shape" in def ? def.shape : undefined;
 }
-function schemaAt(schema, path2) {
+function schemaAt(schema, path) {
   let current = schema;
-  for (const key of path2) {
+  for (const key of path) {
     const unwrapped = unwrap(current);
     if (unwrapped === undefined)
       return;
@@ -15901,10 +15757,10 @@ function describeExpected(expected, schema) {
       return `a ${expected}`;
   }
 }
-function pathText(path2, cliTool) {
-  const [head, ...rest] = path2.map(String);
+function pathText(path, cliTool) {
+  const [head, ...rest] = path.map(String);
   if (cliTool === undefined || head === undefined)
-    return path2.map(String).join(".");
+    return path.map(String).join(".");
   let flag = fieldFlag(cliTool, head);
   let index = 0;
   for (;index < rest.length && /^\d+$/.test(rest[index]); index++) {
@@ -15917,33 +15773,33 @@ function formatZodIssues(issues, schema, tool) {
   const cliTool = isDispatchTool(tool) ? tool : undefined;
   const allowed = Object.keys(shapeOf(schema) ?? {}).join(", ");
   return issues.flatMap((issue2) => {
-    const path2 = pathText(issue2.path, cliTool);
+    const path = pathText(issue2.path, cliTool);
     switch (issue2.code) {
       case "invalid_type":
-        return issue2.input === undefined ? [`${path2} is required (${issue2.expected})`] : [
-          `${path2} must be ${describeExpected(issue2.expected, schemaAt(schema, issue2.path))}, not ${describeInput(issue2.input)}`
+        return issue2.input === undefined ? [`${path} is required (${issue2.expected})`] : [
+          `${path} must be ${describeExpected(issue2.expected, schemaAt(schema, issue2.path))}, not ${describeInput(issue2.input)}`
         ];
       case "unrecognized_keys": {
         if (cliTool !== undefined && issue2.path.length === 0) {
           return issue2.keys.map((key) => `unknown flag ${fieldFlag(cliTool, key)}`);
         }
         const here = Object.keys(shapeOf(schemaAt(schema, issue2.path)) ?? {}).join(", ") || allowed;
-        const where = path2 === "" ? "" : ` in ${path2}`;
+        const where = path === "" ? "" : ` in ${path}`;
         return issue2.keys.map((key) => `unknown field "${key}"${where}; allowed: ${here}`);
       }
       case "invalid_value":
         return [
-          `${path2} must be one of ${issue2.values.map(String).join("|")}; got ${JSON.stringify(issue2.input)}`
+          `${path} must be one of ${issue2.values.map(String).join("|")}; got ${JSON.stringify(issue2.input)}`
         ];
       case "too_big":
         if (issue2.origin === "array" && Array.isArray(issue2.input)) {
-          return [`${path2} has ${issue2.input.length} items; the limit is ${issue2.maximum}`];
+          return [`${path} has ${issue2.input.length} items; the limit is ${issue2.maximum}`];
         }
-        return [`${path2} ${issue2.message}`];
+        return [`${path} ${issue2.message}`];
       case "custom":
         return [issue2.message];
       default:
-        return [path2 === "" ? issue2.message : `${path2}: ${issue2.message}`];
+        return [path === "" ? issue2.message : `${path}: ${issue2.message}`];
     }
   });
 }
@@ -15953,7 +15809,7 @@ var PICTURE_TYPE_NAMES = "a PNG, JPEG, GIF or WebP";
 async function localPictures(images, cwd, problems) {
   if (!Array.isArray(images))
     return [];
-  const checked = await Promise.all(images.map((path2) => localPicture(path2, cwd)));
+  const checked = await Promise.all(images.map((path) => localPicture(path, cwd)));
   const pictures = [];
   for (const outcome of checked) {
     if (typeof outcome === "string")
@@ -15963,30 +15819,30 @@ async function localPictures(images, cwd, problems) {
   }
   return pictures;
 }
-async function localPicture(path2, cwd) {
-  if (typeof path2 !== "string" || path2 === "")
+async function localPicture(path, cwd) {
+  if (typeof path !== "string" || path === "")
     return;
-  const absolute = resolvePath(cwd, path2);
+  const absolute = resolvePath(cwd, path);
   const file2 = Bun.file(absolute);
   let size;
   let head;
   try {
     const stats = await file2.stat();
     if (!stats.isFile())
-      return `images: ${path2} is not a file`;
+      return `images: ${path} is not a file`;
     size = stats.size;
     head = new Uint8Array(await file2.slice(0, PICTURE_SNIFF_BYTES).arrayBuffer());
   } catch (error48) {
-    return `images: ${path2} cannot be read: ${messageFor(error48)}`;
+    return `images: ${path} cannot be read: ${messageFor(error48)}`;
   }
   if (size > PICTURE_UPLOAD_MAX_BYTES) {
-    return `images: ${path2} is ${size.toLocaleString("en-US")} bytes, over the ${PICTURE_UPLOAD_MAX_BYTES / 1024 / 1024} MiB one Dispatch upload takes`;
+    return `images: ${path} is ${size.toLocaleString("en-US")} bytes, over the ${PICTURE_UPLOAD_MAX_BYTES / 1024 / 1024} MiB one Dispatch upload takes`;
   }
   const type = sniffPictureType(head);
   if (type === undefined) {
-    return `images: ${path2} is not ${PICTURE_TYPE_NAMES} picture (judged by its bytes, not its name)`;
+    return `images: ${path} is not ${PICTURE_TYPE_NAMES} picture (judged by its bytes, not its name)`;
   }
-  return { path: path2, name: basename(absolute), file: Bun.file(absolute, { type }) };
+  return { path, name: basename(absolute), file: Bun.file(absolute, { type }) };
 }
 function uploadSlug(name) {
   const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
@@ -17226,11 +17082,11 @@ function anchorLines(record2) {
   ];
 }
 function positionText(block) {
-  const { table, path: path2 } = block;
-  const segments = path2.map((entry) => `${entry.type}[${entry.index}]`);
+  const { table, path } = block;
+  const segments = path.map((entry) => `${entry.type}[${entry.index}]`);
   if (table === undefined || table.row === null)
     return segments.join(" \u203A ");
-  const tableAt = path2.findIndex((entry) => entry.type === "table");
+  const tableAt = path.findIndex((entry) => entry.type === "table");
   const cells = table.cells ?? [];
   const label = (table.column === null ? cells : cells.slice(0, table.column)).map((cell) => cell.trim()).filter((cell) => cell !== "" && !/^\d+$/.test(cell)).join(" \xB7 ");
   const row = label === "" ? `row ${table.row}` : `row ${table.row} (${label})`;
@@ -17471,11 +17327,7 @@ function withAccount(error48, account) {
   return new Error(told, { cause: error48 });
 }
 async function executeDispatchTool(input) {
-  const configUrl = input.config.url;
-  const configToken = input.config.token;
-  if (!input.config.enabled || !configUrl || !configToken) {
-    throw new Error("Dispatch is disabled; resolve both DISPATCH_URL and DISPATCH_TOKEN");
-  }
+  const { url: configUrl, token: configToken } = input.config;
   const baseFetch = input.fetchImpl ?? fetch;
   const fetchImpl = Object.assign(async (...args2) => {
     try {
@@ -18428,15 +18280,15 @@ import {
   mkdirSync,
   openSync,
   readdirSync,
-  readFileSync as readFileSync3,
+  readFileSync,
   readSync,
   renameSync,
   rmSync,
   statSync,
   writeFileSync
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { homedir } from "os";
+import { join } from "path";
 var SESSION_ID = /^[A-Za-z0-9._-]{1,128}$/;
 var PRIVATE_DIR = 448;
 var PRIVATE_FILE = 384;
@@ -18452,44 +18304,44 @@ var PICTURE_EXTENSIONS = {
 function sessionStateRoot(env) {
   if (env.DISPATCH_STATE_DIR)
     return env.DISPATCH_STATE_DIR;
-  return join2(env.XDG_STATE_HOME || join2(homedir2(), ".local", "state"), "dispatch");
+  return join(env.XDG_STATE_HOME || join(homedir(), ".local", "state"), "dispatch");
 }
 function sessionDirectory(env, sessionId) {
   if (!SESSION_ID.test(sessionId) || sessionId === "." || sessionId === "..") {
     throw new Error(`dispatch: the session id ${JSON.stringify(sessionId)} is not 1-128 letters, digits, ".", "_" or "-"`);
   }
-  return join2(sessionStateRoot(env), "sessions", sessionId);
+  return join(sessionStateRoot(env), "sessions", sessionId);
 }
 function ensureDirectory(dir) {
   mkdirSync(dir, { recursive: true, mode: PRIVATE_DIR });
 }
-function readIfPresent(path2) {
+function readIfPresent(path) {
   try {
-    return readFileSync3(path2, "utf-8");
+    return readFileSync(path, "utf-8");
   } catch (error48) {
     if (hasErrnoCode(error48, "ENOENT"))
       return;
     throw error48;
   }
 }
-function writeAtomically(path2, text) {
-  const temporary = `${path2}.${process.pid}.${Date.now()}.tmp`;
+function writeAtomically(path, text) {
+  const temporary = `${path}.${process.pid}.${Date.now()}.tmp`;
   writeFileSync(temporary, text, { mode: PRIVATE_FILE });
-  renameSync(temporary, path2);
+  renameSync(temporary, path);
 }
 function stringList(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 function loadSessionMemory(dir, sessionId) {
-  const path2 = join2(dir, "state.json");
-  const text = readIfPresent(path2);
+  const path = join(dir, "state.json");
+  const text = readIfPresent(path);
   if (text === undefined)
     return new Set;
   let state;
   try {
     state = JSON.parse(text);
   } catch (error48) {
-    throw new Error(`the session state ${path2} is not JSON (${error48.message}); remove it to start this session's memory over`);
+    throw new Error(`the session state ${path} is not JSON (${error48.message}); remove it to start this session's memory over`);
   }
   const advice = adviceMemory();
   for (const key of stringList(state.advice))
@@ -18505,12 +18357,12 @@ function writeMemory(dir, sessionId, follows) {
     pictures: [...shownPictures(sessionId)],
     follows: [...follows]
   };
-  writeAtomically(join2(dir, "state.json"), `${JSON.stringify(state)}
+  writeAtomically(join(dir, "state.json"), `${JSON.stringify(state)}
 `);
 }
 function writeResult(dir, entry) {
   const line = { at: new Date().toISOString(), ...entry };
-  appendFileSync(join2(dir, "results.jsonl"), `${JSON.stringify(line)}
+  appendFileSync(join(dir, "results.jsonl"), `${JSON.stringify(line)}
 `, { mode: PRIVATE_FILE });
 }
 function recordOutcome(dir, sessionId, follows, entry) {
@@ -18521,29 +18373,29 @@ function recordOutcome(dir, sessionId, follows, entry) {
 function writePicture(dir, image) {
   const bytes = Buffer.from(image.data, "base64");
   const name = createHash("sha256").update(bytes).digest("hex").slice(0, 16);
-  const pictures = join2(dir, "pictures");
-  const path2 = join2(pictures, `${name}.${PICTURE_EXTENSIONS[image.mimeType]}`);
+  const pictures = join(dir, "pictures");
+  const path = join(pictures, `${name}.${PICTURE_EXTENSIONS[image.mimeType]}`);
   ensureDirectory(pictures);
   try {
-    writeFileSync(path2, bytes, { mode: PRIVATE_FILE, flag: "wx" });
+    writeFileSync(path, bytes, { mode: PRIVATE_FILE, flag: "wx" });
   } catch (error48) {
     if (!hasErrnoCode(error48, "EEXIST"))
       throw error48;
   }
-  return { path: path2, bytes: bytes.length };
+  return { path, bytes: bytes.length };
 }
 function writeLongOutput(dir, text) {
-  const out = join2(dir, "out");
+  const out = join(dir, "out");
   ensureDirectory(out);
-  const path2 = join2(out, `${new Date().toISOString().replaceAll(":", "-")}-${process.pid}.md`);
-  writeFileSync(path2, text, { mode: PRIVATE_FILE });
-  return path2;
+  const path = join(out, `${new Date().toISOString().replaceAll(":", "-")}-${process.pid}.md`);
+  writeFileSync(path, text, { mode: PRIVATE_FILE });
+  return path;
 }
 function readSessionTitle(dir) {
-  return readIfPresent(join2(dir, "title")) || undefined;
+  return readIfPresent(join(dir, "title")) || undefined;
 }
 function pruneSessions(root, now) {
-  const stamp = join2(root, PRUNED_STAMP);
+  const stamp = join(root, PRUNED_STAMP);
   try {
     if (now - statSync(stamp).mtimeMs < PRUNE_INTERVAL_MS)
       return;
@@ -18551,7 +18403,7 @@ function pruneSessions(root, now) {
     if (!hasErrnoCode(error48, "ENOENT"))
       throw error48;
   }
-  const sessions = join2(root, "sessions");
+  const sessions = join(root, "sessions");
   let entries = [];
   try {
     entries = readdirSync(sessions, { withFileTypes: true });
@@ -18562,7 +18414,7 @@ function pruneSessions(root, now) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const dir = join2(sessions, entry.name);
+    const dir = join(sessions, entry.name);
     try {
       if (now - statSync(dir).mtimeMs > IDLE_SESSION_MS) {
         rmSync(dir, { recursive: true, force: true });
@@ -18603,11 +18455,575 @@ function dispatchFollowNotice(details) {
   };
 }
 
+// ../envoy-client/src/envoy-config.ts
+import {
+  chmodSync,
+  closeSync as closeSync2,
+  existsSync,
+  lstatSync,
+  mkdtempSync,
+  openSync as openSync2,
+  readFileSync as readFileSync3,
+  readlinkSync,
+  rmSync as rmSync2,
+  statSync as statSync2
+} from "fs";
+import { homedir as homedir2, tmpdir } from "os";
+import * as path from "path";
+
+// ../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 as readFileSync2 } from "fs";
+function sendable(value) {
+  return !/[\s\p{Cc}]/u.test(value);
+}
+function readSecretFile(variable, filePath) {
+  let contents;
+  try {
+    contents = readFileSync2(filePath, "utf8");
+  } catch (error48) {
+    throw new Error(`${variable} names ${filePath}, which could not be read: ${messageFor(error48)}`);
+  }
+  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/envoy-config.ts
+var COMMAND_TIMEOUT_MS = 1e4;
+function nonEmpty(value) {
+  return value === undefined || value === "" ? undefined : value;
+}
+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) ?? homedir2(), ".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(),
+  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 envoy.json`;
+  if (issue2.code === "unrecognized_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 danglingLink(filePath) {
+  try {
+    return lstatSync(filePath).isSymbolicLink() ? readlinkSync(filePath) : null;
+  } catch {
+    return null;
+  }
+}
+function parseFile(filePath, schema, checkout) {
+  let raw;
+  try {
+    raw = readFileSync3(filePath, "utf-8");
+  } 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 {
+    const position = jsonErrorPosition(raw);
+    return {
+      kind: "invalid",
+      reason: `${filePath}: invalid JSON${position === undefined ? "" : ` at ${position}`}`
+    };
+  }
+  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 };
+}
+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 = openSync2(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 {
+      closeSync2(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 {
+        failure: `exited with ${result.signalCode ?? `status ${result.exitCode}`}`,
+        timedOut: false
+      };
+    }
+    const value = readFileSync3(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 {
+    rmSync2(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 statSync2(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) ?? homedir2();
+  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/session-settings.ts
+function sessionConfigFile(harness, env) {
+  try {
+    return { path: envoyConfigPath(harness, env), error: null };
+  } catch (error48) {
+    return { path: null, error: messageFor(error48) };
+  }
+}
+function handedConfigFile(env) {
+  try {
+    const handed = handedConfigPath(env);
+    return handed === undefined ? null : { path: handed, error: null };
+  } catch (error48) {
+    return { path: null, error: messageFor(error48) };
+  }
+}
+function sessionDispatchSettings(file2, env, options) {
+  if (file2.path === null)
+    return { dispatch: offWithError(file2.error), warnings: [], missing: null };
+  const config2 = readEnvoyConfig(file2.path, env, options);
+  return {
+    dispatch: dispatchSettings(env, config2),
+    warnings: config2.kind === "read" ? config2.warnings : [],
+    missing: config2.kind === "read" ? config2.missing : null
+  };
+}
+
 // ../envoy-client/src/dispatch-cli.ts
 var OK = 0;
 var REFUSED = 1;
 var USAGE = 2;
-var HOSTS = { omp: "omp", claude: "claude", opencode: "opencode" };
+var HOSTS = ["omp", "claude", "opencode"];
 var CLAUDE_OUTPUT_MAX = 25000;
 var STATE_WRITE_FAILED = "dispatch: Dispatch took the call, but this session's state";
 function stateWriteFailed(problem) {
@@ -18675,8 +19091,8 @@ async function runDispatchCli(argv, rawEnv, io) {
     print(new ToolInputError(parsed.tool, parsed.problems).message);
     return REFUSED;
   }
-  const hostName = env.DISPATCH_HOST;
-  const host = hostName === undefined ? undefined : HOSTS[hostName];
+  const hostName = env.DISPATCH_HOST ?? (env.CLAUDE_CODE_CHILD_SESSION === "1" ? "claude" : undefined);
+  const host = HOSTS.find((name) => name === hostName);
   if (host === undefined) {
     print(hostName === undefined ? "dispatch: DISPATCH_HOST is not set. The host plugin sets it in an agent's shell; to run dispatch by hand, set DISPATCH_HOST and DISPATCH_SESSION_ID yourself." : `dispatch: DISPATCH_HOST is ${JSON.stringify(hostName)}, not omp, claude or opencode.`);
     return USAGE;
@@ -18698,17 +19114,19 @@ async function runDispatchCli(argv, rawEnv, io) {
     print(JSON.stringify(parsed.args, null, 2));
     return OK;
   }
-  let config2;
-  try {
-    config2 = activeDispatchConfig(env, { cwd: io.cwd });
-  } catch (error48) {
-    print(`dispatch: ${messageFor(error48)}`);
+  const file2 = (env.DISPATCH_HOST === undefined ? null : handedConfigFile(env)) ?? sessionConfigFile(host, env);
+  if (file2.path === null) {
+    print(`dispatch: ${file2.error}`);
     return USAGE;
   }
-  if (config2 === null) {
-    print("dispatch: Dispatch is not configured (DISPATCH_URL with DISPATCH_TOKEN or DISPATCH_TOKEN_FILE, or envoy.json)");
+  const { dispatch: resolution, warnings } = sessionDispatchSettings(file2, env, { cwd: io.cwd });
+  for (const warning of warnings)
+    print(`dispatch: ${warning}`);
+  if (!resolution.enabled) {
+    print(resolution.error === null ? `dispatch: ${resolution.notice}` : `dispatch: dispatch config: ${resolution.error}`);
     return USAGE;
   }
+  const config2 = resolution;
   let follows;
   try {
     pruneSessions(sessionStateRoot(env), Date.now());