@sjawhar/opencode-legion-envoy 0.9.0 → 0.10.0

package/dist/src/server.js

@@ -1,7 +1,7 @@
 // @bun
 // src/server.ts
-import { existsSync as existsSync3 } from "fs";
-import path4 from "path";
+import { existsSync } from "fs";
+import path3 from "path";
 import { fileURLToPath } from "url";
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.js
@@ -86,6 +86,9 @@ function getEnumValues(entries) {
   const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
   return values;
 }
+function joinValues(array, separator = "|") {
+  return array.map((val) => stringifyPrimitive(val)).join(separator);
+}
 function jsonStringifyReplacer(_, value) {
   if (typeof value === "bigint")
     return value.toString();
@@ -237,6 +240,13 @@ function normalizeParams(_params) {
     return { ...params, error: () => params.error };
   return params;
 }
+function stringifyPrimitive(value) {
+  if (typeof value === "bigint")
+    return value.toString() + "n";
+  if (typeof value === "string")
+    return `"${value}"`;
+  return `${value}`;
+}
 function optionalKeys(shape) {
   return Object.keys(shape).filter((k) => {
     return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
@@ -459,6 +469,27 @@ function getLengthableOrigin(input) {
     return "string";
   return "unknown";
 }
+function parsedType(data) {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "nan" : "number";
+    }
+    case "object": {
+      if (data === null) {
+        return "null";
+      }
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      const obj = data;
+      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+        return obj.constructor.name;
+      }
+    }
+  }
+  return t;
+}
 function issue(...args) {
   const [iss, input, inst] = args;
   if (typeof iss === "string") {
@@ -2473,6 +2504,112 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/locales/en.js
+var error = () => {
+  const Sizable = {
+    string: { unit: "characters", verb: "to have" },
+    file: { unit: "bytes", verb: "to have" },
+    array: { unit: "items", verb: "to have" },
+    set: { unit: "items", verb: "to have" },
+    map: { unit: "entries", verb: "to have" }
+  };
+  function getSizing(origin) {
+    return Sizable[origin] ?? null;
+  }
+  const FormatDictionary = {
+    regex: "input",
+    email: "email address",
+    url: "URL",
+    emoji: "emoji",
+    uuid: "UUID",
+    uuidv4: "UUIDv4",
+    uuidv6: "UUIDv6",
+    nanoid: "nanoid",
+    guid: "GUID",
+    cuid: "cuid",
+    cuid2: "cuid2",
+    ulid: "ULID",
+    xid: "XID",
+    ksuid: "KSUID",
+    datetime: "ISO datetime",
+    date: "ISO date",
+    time: "ISO time",
+    duration: "ISO duration",
+    ipv4: "IPv4 address",
+    ipv6: "IPv6 address",
+    mac: "MAC address",
+    cidrv4: "IPv4 range",
+    cidrv6: "IPv6 range",
+    base64: "base64-encoded string",
+    base64url: "base64url-encoded string",
+    json_string: "JSON string",
+    e164: "E.164 number",
+    jwt: "JWT",
+    template_literal: "input"
+  };
+  const TypeDictionary = {
+    nan: "NaN"
+  };
+  return (issue) => {
+    switch (issue.code) {
+      case "invalid_type": {
+        const expected = TypeDictionary[issue.expected] ?? issue.expected;
+        const receivedType = parsedType(issue.input);
+        const received = TypeDictionary[receivedType] ?? receivedType;
+        return `Invalid input: expected ${expected}, received ${received}`;
+      }
+      case "invalid_value":
+        if (issue.values.length === 1)
+          return `Invalid input: expected ${stringifyPrimitive(issue.values[0])}`;
+        return `Invalid option: expected one of ${joinValues(issue.values, "|")}`;
+      case "too_big": {
+        const adj = issue.inclusive ? "<=" : "<";
+        const sizing = getSizing(issue.origin);
+        if (sizing)
+          return `Too big: expected ${issue.origin ?? "value"} to have ${adj}${issue.maximum.toString()} ${sizing.unit ?? "elements"}`;
+        return `Too big: expected ${issue.origin ?? "value"} to be ${adj}${issue.maximum.toString()}`;
+      }
+      case "too_small": {
+        const adj = issue.inclusive ? ">=" : ">";
+        const sizing = getSizing(issue.origin);
+        if (sizing) {
+          return `Too small: expected ${issue.origin} to have ${adj}${issue.minimum.toString()} ${sizing.unit}`;
+        }
+        return `Too small: expected ${issue.origin} to be ${adj}${issue.minimum.toString()}`;
+      }
+      case "invalid_format": {
+        const _issue = issue;
+        if (_issue.format === "starts_with") {
+          return `Invalid string: must start with "${_issue.prefix}"`;
+        }
+        if (_issue.format === "ends_with")
+          return `Invalid string: must end with "${_issue.suffix}"`;
+        if (_issue.format === "includes")
+          return `Invalid string: must include "${_issue.includes}"`;
+        if (_issue.format === "regex")
+          return `Invalid string: must match pattern ${_issue.pattern}`;
+        return `Invalid ${FormatDictionary[_issue.format] ?? issue.format}`;
+      }
+      case "not_multiple_of":
+        return `Invalid number: must be a multiple of ${issue.divisor}`;
+      case "unrecognized_keys":
+        return `Unrecognized key${issue.keys.length > 1 ? "s" : ""}: ${joinValues(issue.keys, ", ")}`;
+      case "invalid_key":
+        return `Invalid key in ${issue.origin}`;
+      case "invalid_union":
+        return "Invalid input";
+      case "invalid_element":
+        return `Invalid value in ${issue.origin}`;
+      default:
+        return `Invalid input`;
+    }
+  };
+};
+function en_default() {
+  return {
+    localeError: error()
+  };
+}
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/registries.js
 var _a;
 var $output = Symbol("ZodOutput");
@@ -3415,10 +3552,45 @@ var numberProcessor = (schema, ctx, _json, _params) => {
 var booleanProcessor = (_schema, _ctx, json, _params) => {
   json.type = "boolean";
 };
+var bigintProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("BigInt cannot be represented in JSON Schema");
+  }
+};
+var symbolProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Symbols cannot be represented in JSON Schema");
+  }
+};
+var nullProcessor = (_schema, ctx, json, _params) => {
+  if (ctx.target === "openapi-3.0") {
+    json.type = "string";
+    json.nullable = true;
+    json.enum = [null];
+  } else {
+    json.type = "null";
+  }
+};
+var undefinedProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Undefined cannot be represented in JSON Schema");
+  }
+};
+var voidProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Void cannot be represented in JSON Schema");
+  }
+};
 var neverProcessor = (_schema, _ctx, json, _params) => {
   json.not = {};
 };
+var anyProcessor = (_schema, _ctx, _json, _params) => {};
 var unknownProcessor = (_schema, _ctx, _json, _params) => {};
+var dateProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Date cannot be represented in JSON Schema");
+  }
+};
 var enumProcessor = (schema, _ctx, json, _params) => {
   const def = schema._zod.def;
   const values = getEnumValues(def.entries);
@@ -3466,16 +3638,71 @@ var literalProcessor = (schema, ctx, json, _params) => {
     json.enum = vals;
   }
 };
+var nanProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("NaN cannot be represented in JSON Schema");
+  }
+};
+var templateLiteralProcessor = (schema, _ctx, json, _params) => {
+  const _json = json;
+  const pattern = schema._zod.pattern;
+  if (!pattern)
+    throw new Error("Pattern not found in template literal");
+  _json.type = "string";
+  _json.pattern = pattern.source;
+};
+var fileProcessor = (schema, _ctx, json, _params) => {
+  const _json = json;
+  const file = {
+    type: "string",
+    format: "binary",
+    contentEncoding: "binary"
+  };
+  const { minimum, maximum, mime } = schema._zod.bag;
+  if (minimum !== undefined)
+    file.minLength = minimum;
+  if (maximum !== undefined)
+    file.maxLength = maximum;
+  if (mime) {
+    if (mime.length === 1) {
+      file.contentMediaType = mime[0];
+      Object.assign(_json, file);
+    } else {
+      Object.assign(_json, file);
+      _json.anyOf = mime.map((m) => ({ contentMediaType: m }));
+    }
+  } else {
+    Object.assign(_json, file);
+  }
+};
+var successProcessor = (_schema, _ctx, json, _params) => {
+  json.type = "boolean";
+};
 var customProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
     throw new Error("Custom types cannot be represented in JSON Schema");
   }
 };
+var functionProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Function types cannot be represented in JSON Schema");
+  }
+};
 var transformProcessor = (_schema, ctx, _json, _params) => {
   if (ctx.unrepresentable === "throw") {
     throw new Error("Transforms cannot be represented in JSON Schema");
   }
 };
+var mapProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Map cannot be represented in JSON Schema");
+  }
+};
+var setProcessor = (_schema, ctx, _json, _params) => {
+  if (ctx.unrepresentable === "throw") {
+    throw new Error("Set cannot be represented in JSON Schema");
+  }
+};
 var arrayProcessor = (schema, ctx, _json, params) => {
   const json = _json;
   const def = schema._zod.def;
@@ -3553,6 +3780,48 @@ var intersectionProcessor = (schema, ctx, json, params) => {
   ];
   json.allOf = allOf;
 };
+var tupleProcessor = (schema, ctx, _json, params) => {
+  const json = _json;
+  const def = schema._zod.def;
+  json.type = "array";
+  const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
+  const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
+    ...params,
+    path: [...params.path, prefixPath, i]
+  }));
+  const rest = def.rest ? process2(def.rest, ctx, {
+    ...params,
+    path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
+  }) : null;
+  if (ctx.target === "draft-2020-12") {
+    json.prefixItems = prefixItems;
+    if (rest) {
+      json.items = rest;
+    }
+  } else if (ctx.target === "openapi-3.0") {
+    json.items = {
+      anyOf: prefixItems
+    };
+    if (rest) {
+      json.items.anyOf.push(rest);
+    }
+    json.minItems = prefixItems.length;
+    if (!rest) {
+      json.maxItems = prefixItems.length;
+    }
+  } else {
+    json.items = prefixItems;
+    if (rest) {
+      json.additionalItems = rest;
+    }
+  }
+  const { minimum, maximum } = schema._zod.bag;
+  if (typeof minimum === "number")
+    json.minItems = minimum;
+  if (typeof maximum === "number")
+    json.maxItems = maximum;
+};
 var recordProcessor = (schema, ctx, _json, params) => {
   const json = _json;
   const def = schema._zod.def;
@@ -3648,12 +3917,99 @@ var readonlyProcessor = (schema, ctx, json, params) => {
   seen.ref = def.innerType;
   json.readOnly = true;
 };
+var promiseProcessor = (schema, ctx, _json, params) => {
+  const def = schema._zod.def;
+  process2(def.innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = def.innerType;
+};
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
+var lazyProcessor = (schema, ctx, _json, params) => {
+  const innerType = schema._zod.innerType;
+  process2(innerType, ctx, params);
+  const seen = ctx.seen.get(schema);
+  seen.ref = innerType;
+};
+var allProcessors = {
+  string: stringProcessor,
+  number: numberProcessor,
+  boolean: booleanProcessor,
+  bigint: bigintProcessor,
+  symbol: symbolProcessor,
+  null: nullProcessor,
+  undefined: undefinedProcessor,
+  void: voidProcessor,
+  never: neverProcessor,
+  any: anyProcessor,
+  unknown: unknownProcessor,
+  date: dateProcessor,
+  enum: enumProcessor,
+  literal: literalProcessor,
+  nan: nanProcessor,
+  template_literal: templateLiteralProcessor,
+  file: fileProcessor,
+  success: successProcessor,
+  custom: customProcessor,
+  function: functionProcessor,
+  transform: transformProcessor,
+  map: mapProcessor,
+  set: setProcessor,
+  array: arrayProcessor,
+  object: objectProcessor,
+  union: unionProcessor,
+  intersection: intersectionProcessor,
+  tuple: tupleProcessor,
+  record: recordProcessor,
+  nullable: nullableProcessor,
+  nonoptional: nonoptionalProcessor,
+  default: defaultProcessor,
+  prefault: prefaultProcessor,
+  catch: catchProcessor,
+  pipe: pipeProcessor,
+  readonly: readonlyProcessor,
+  promise: promiseProcessor,
+  optional: optionalProcessor,
+  lazy: lazyProcessor
+};
+function toJSONSchema(input, params) {
+  if ("_idmap" in input) {
+    const registry = input;
+    const ctx = initializeContext({ ...params, processors: allProcessors });
+    const defs = {};
+    for (const entry of registry._idmap.entries()) {
+      const [_, schema] = entry;
+      process2(schema, ctx);
+    }
+    const schemas = {};
+    const external = {
+      registry,
+      uri: params?.uri,
+      defs
+    };
+    ctx.external = external;
+    for (const entry of registry._idmap.entries()) {
+      const [key, schema] = entry;
+      extractDefs(ctx, schema);
+      schemas[key] = finalize(ctx, schema);
+    }
+    if (Object.keys(defs).length > 0) {
+      const defsSegment = ctx.target === "draft-2020-12" ? "$defs" : "definitions";
+      schemas.__shared = {
+        [defsSegment]: defs
+      };
+    }
+    return { schemas };
+  }
+  const ctx = initializeContext({ ...params, processors: allProcessors });
+  process2(input, ctx);
+  extractDefs(ctx, input);
+  return finalize(ctx, input);
+}
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/iso.js
 var ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
   $ZodISODateTime.init(inst, def);
@@ -4372,6 +4728,8 @@ function refine(fn, _params = {}) {
 function superRefine(fn) {
   return _superRefine(fn);
 }
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
+config(en_default());
 // ../contracts/src/envelope.ts
 var isSubject = (value) => typeof value === "string" && value.length > 0;
 var EnvelopeSchema = object({
@@ -4669,11 +5027,382 @@ function normalizeEnvoyUrl(value) {
   return value.replace(/\/+$/, "");
 }
 
+// ../envoy-client/src/dispatch-contract.ts
+var DISPATCH_TOOL_NAME = "dispatch";
+var DISPATCH_CONTEXT_MAX = 1200;
+var DISPATCH_QUESTION_MAX = 800;
+var DISPATCH_URGENCIES = ["low", "med", "high", "blocking"];
+var DISPATCH_TOOL_DESCRIPTION = "Raise a durable question to the human as a Dispatch thread (a GitHub issue shown on the dashboard), or continue an existing thread with a follow-up question. The reader has NOT seen your transcript. Open a thread with `subject`; continue one with `thread`. The reply arrives in this session as a steer.";
+var DISPATCH_ARGUMENTS = {
+  subject: "Open a new thread: one line naming the decision needed (the issue title). Omit when continuing a thread with `thread`.",
+  thread: `Continue an existing thread: "<n>" (an issue in the working directory's repo) or "owner/name#<n>". When set, omit subject, urgency, repo, and parent.`,
+  context: `What you are doing, what you found, why you are stuck \u2014 at most ${DISPATCH_CONTEXT_MAX} characters, at most three short paragraphs or a bullet list. The reader has NOT seen your transcript: no nouns you coined this session, no internal identifiers unless the question is about them. GitHub references (#N, owner/repo#N, URLs) may be bare; the dashboard unfurls them.`,
+  question: `The ask, at most ${DISPATCH_QUESTION_MAX} characters, as a list: current state \u2192 desired state \u2192 your recommendation and why; options go in \`ask\`.`,
+  ask: "Structured questions rendered as buttons on the dashboard. Each: { question, header?, options: [{ label, description? }], multiple?, custom? }. Use this whenever the answer is one of N choices.",
+  urgency: "low | med | high | blocking (default med). Opening a thread only.",
+  repo: "owner/name. Opening a thread only; defaults to the working directory's GitHub repo.",
+  parent: "<n> | owner/name#<n>[#<commentId>]. Opening a thread only: link the thread as a sub-issue of an existing issue and append a breadcrumb to the comment."
+};
+
+class DispatchArgumentError extends Error {
+  name = "DispatchArgumentError";
+}
+var QuestionOptionSchema = strictObject({
+  label: string2().min(1),
+  description: string2().optional()
+});
+var DispatchQuestionSchema = strictObject({
+  question: string2().min(1),
+  header: string2().optional(),
+  options: array(QuestionOptionSchema).optional(),
+  multiple: boolean2().optional(),
+  custom: boolean2().optional()
+});
+var prose = {
+  context: string2(),
+  question: string2(),
+  ask: array(DispatchQuestionSchema).optional()
+};
+var OpenThreadCallSchema = strictObject({
+  subject: string2(),
+  ...prose,
+  urgency: _enum(DISPATCH_URGENCIES).optional(),
+  repo: string2().optional(),
+  parent: string2().optional()
+});
+var ContinueThreadCallSchema = strictObject({ thread: string2(), ...prose });
+var dispatchToolShape = {
+  subject: string2().describe(DISPATCH_ARGUMENTS.subject).optional(),
+  thread: string2().describe(DISPATCH_ARGUMENTS.thread).optional(),
+  context: string2().describe(DISPATCH_ARGUMENTS.context),
+  question: string2().describe(DISPATCH_ARGUMENTS.question),
+  ask: array(DispatchQuestionSchema).describe(DISPATCH_ARGUMENTS.ask).optional(),
+  urgency: _enum(DISPATCH_URGENCIES).describe(DISPATCH_ARGUMENTS.urgency).optional(),
+  repo: string2().describe(DISPATCH_ARGUMENTS.repo).optional(),
+  parent: string2().describe(DISPATCH_ARGUMENTS.parent).optional()
+};
+var DISPATCH_TOOL_JSON_SCHEMA = toJSONSchema(object(dispatchToolShape));
+function isContinueCall(call) {
+  return "thread" in call;
+}
+function present(raw) {
+  return Object.fromEntries(Object.entries(raw).filter(([, value]) => value !== undefined));
+}
+function describeIssues(error) {
+  return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+}
+function parseDispatchCall(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new DispatchArgumentError("dispatch: invalid arguments \u2014 expected an object");
+  }
+  const args = present(raw);
+  const hasSubject = "subject" in args;
+  const hasThread = "thread" in args;
+  if (hasSubject && hasThread) {
+    throw new DispatchArgumentError("dispatch: pass either subject (open a thread) or thread (continue one), not both");
+  }
+  if (!hasSubject && !hasThread) {
+    throw new DispatchArgumentError("dispatch: subject or thread is required");
+  }
+  if (hasThread && (("urgency" in args) || ("repo" in args) || ("parent" in args))) {
+    throw new DispatchArgumentError("dispatch: thread cannot be combined with urgency, repo, or parent");
+  }
+  const parsed = hasThread ? ContinueThreadCallSchema.safeParse(args) : OpenThreadCallSchema.safeParse(args);
+  if (!parsed.success) {
+    throw new DispatchArgumentError(`dispatch: invalid arguments \u2014 ${describeIssues(parsed.error)}`);
+  }
+  return parsed.data;
+}
+
+// ../envoy-client/src/dispatch-cwd.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+
+// ../envoy-client/src/machine.ts
+import { hostname } from "os";
+function machineID() {
+  return process.env["ENVOY_MACHINE_ID"] || hostname();
+}
+
+// ../envoy-client/src/dispatch-cwd.ts
+var execFileAsync = promisify(execFile);
+var defaultExec = (file, args, options) => execFileAsync(file, args, { cwd: options.cwd, timeout: 5000 });
+async function tryExec(exec, file, args, cwd) {
+  try {
+    const { stdout } = await exec(file, args, { cwd });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+function parseRemoteList(stdout) {
+  const remotes = new Map;
+  for (const line of stdout.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const match = trimmed.match(/^(\S+)\s+(\S+)/);
+    const [, name, url] = match ?? [];
+    if (name && url)
+      remotes.set(name, url);
+  }
+  return remotes;
+}
+function selectRemoteUrl(remotes) {
+  const origin = remotes.get("origin");
+  if (origin)
+    return origin;
+  const candidates = [...remotes.entries()].filter(([name]) => name !== "upstream");
+  return candidates.length === 1 ? candidates[0]?.[1] ?? null : null;
+}
+var GITHUB_REMOTE_PATTERNS = [
+  /^https:\/\/(?:[^@/\s]+@)?github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i,
+  /^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?\/?$/i,
+  /^ssh:\/\/git@github\.com\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/i
+];
+function parseGitHubRemoteUrl(url) {
+  const trimmed = url.trim();
+  for (const pattern of GITHUB_REMOTE_PATTERNS) {
+    const match = trimmed.match(pattern);
+    if (match)
+      return `${match[1]}/${match[2]}`;
+  }
+  return null;
+}
+async function resolveCwdRepo(cwd, exec) {
+  const jjOutput = await tryExec(exec, "jj", ["git", "remote", "list"], cwd);
+  if (jjOutput !== null) {
+    const url = selectRemoteUrl(parseRemoteList(jjOutput));
+    return url ? parseGitHubRemoteUrl(url) : null;
+  }
+  const originUrl = await tryExec(exec, "git", ["remote", "get-url", "origin"], cwd);
+  return originUrl ? parseGitHubRemoteUrl(originUrl) : null;
+}
+async function resolveOrigin(env, exec, cwd) {
+  const origin = {
+    cwd,
+    machine: machineID()
+  };
+  const pane = env["TMUX_PANE"];
+  if (pane) {
+    const output = await tryExec(exec, "tmux", ["display-message", "-p", "-t", pane, "#S:#I.#P #{pane_id}"], cwd);
+    const [target, paneId] = output?.trim().split(" ") ?? [];
+    if (target)
+      origin.tmux = target;
+    if (paneId)
+      origin.pane = paneId;
+  }
+  return origin;
+}
+
+// ../envoy-client/src/errors.ts
+function messageFor(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// ../envoy-client/src/dispatch-client.ts
+function ghTokenGetter(cwd, exec = defaultExec) {
+  return async () => {
+    try {
+      const { stdout } = await exec("gh", ["auth", "token"], { cwd });
+      const value = stdout.trim();
+      return value.length > 0 ? value : null;
+    } catch {
+      return null;
+    }
+  };
+}
+
+class DispatchServiceError extends Error {
+  kind;
+  name = "DispatchServiceError";
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+  }
+}
+function parseResponseBody(body, contentType) {
+  if (!contentType.includes("text/event-stream"))
+    return JSON.parse(body);
+  for (const line of body.split(`
+`)) {
+    const payload = line.match(/^data:\s*(.+)$/)?.[1];
+    if (payload !== undefined)
+      return JSON.parse(payload);
+  }
+  return null;
+}
+function isDispatchServiceResult(value) {
+  return typeof value === "object" && value !== null && "thread" in value && typeof value.thread === "number" && "url" in value && typeof value.url === "string";
+}
+async function callDispatch(options, args) {
+  const token = await options.getToken();
+  if (!token) {
+    throw new DispatchServiceError("auth", `dispatch: gh auth token returned empty in ${args.origin.cwd} \u2014 check your gh-app setup`);
+  }
+  const fetchImpl = options.fetchImpl ?? fetch;
+  let response;
+  try {
+    response = await fetchImpl(options.serviceUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        Accept: "application/json, text/event-stream"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: DISPATCH_TOOL_NAME, arguments: args }
+      })
+    });
+  } catch (error) {
+    throw new DispatchServiceError("transport", `dispatch service unreachable at ${options.serviceUrl}: ${messageFor(error)}`);
+  }
+  const body = await response.text();
+  if (response.status === 401) {
+    throw new DispatchServiceError("auth", `dispatch service rejected the GitHub token (401): ${body.slice(0, 200)}`);
+  }
+  if (!response.ok) {
+    throw new DispatchServiceError("transport", `dispatch service returned ${response.status} ${response.statusText}: ${body.slice(0, 200)}`);
+  }
+  let parsed;
+  try {
+    parsed = parseResponseBody(body, response.headers.get("content-type") ?? "");
+  } catch (error) {
+    throw new DispatchServiceError("transport", `dispatch service sent an unreadable response: ${messageFor(error)}`);
+  }
+  const rpc = parsed ?? {};
+  if (rpc.error) {
+    throw new DispatchServiceError("tool", rpc.error.message ?? "dispatch service returned an error");
+  }
+  const text = (rpc.result?.content ?? []).map((item) => item.text ?? "").filter(Boolean).join(`
+`);
+  if (rpc.result?.isError)
+    throw new DispatchServiceError("tool", text || "dispatch failed");
+  let result;
+  try {
+    result = JSON.parse(text);
+  } catch {
+    throw new DispatchServiceError("transport", `dispatch service returned a non-JSON result: ${text.slice(0, 200)}`);
+  }
+  if (!isDispatchServiceResult(result)) {
+    throw new DispatchServiceError("transport", `dispatch service result lacks thread/url: ${text.slice(0, 200)}`);
+  }
+  return result;
+}
+
+// ../envoy-client/src/dispatch-call.ts
+var QUALIFIED_REF = /^[^/\s#]+\/[^/\s#]+#\d+/;
+async function prepareDispatchCall(input) {
+  const { call, cwd } = input;
+  const continuing = isContinueCall(call);
+  const needsRepo = continuing ? !QUALIFIED_REF.test(call.thread) : call.repo === undefined && !QUALIFIED_REF.test(call.parent ?? "");
+  let repo;
+  if (needsRepo) {
+    const resolved = await resolveCwdRepo(cwd, input.exec);
+    if (resolved === null) {
+      throw new DispatchArgumentError(continuing ? `dispatch: ${cwd} has no GitHub remote; pass thread=owner/name#<n>` : `dispatch: ${cwd} has no GitHub remote; pass repo=owner/name`);
+    }
+    repo = resolved;
+  }
+  const resolvedOrigin = await resolveOrigin(input.env, input.exec, cwd);
+  const origin = {
+    ...resolvedOrigin,
+    host: input.host,
+    ...input.sessionId ? { sessionId: input.sessionId } : {},
+    ...input.sessionTitle ? { sessionTitle: input.sessionTitle } : {}
+  };
+  return { ...call, ...repo === undefined ? {} : { repo }, origin };
+}
+async function executeDispatch(input) {
+  const exec = input.exec ?? defaultExec;
+  const prepared = await prepareDispatchCall({
+    call: input.call,
+    cwd: input.cwd,
+    host: input.host,
+    ...input.sessionId === undefined ? {} : { sessionId: input.sessionId },
+    ...input.sessionTitle === undefined ? {} : { sessionTitle: input.sessionTitle },
+    env: input.env ?? process.env,
+    exec
+  });
+  return callDispatch({
+    serviceUrl: input.serviceUrl,
+    getToken: input.getToken ?? ghTokenGetter(input.cwd, exec),
+    ...input.fetchImpl ? { fetchImpl: input.fetchImpl } : {}
+  }, prepared);
+}
+
+// ../envoy-client/src/dispatch-config.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import * as path from "path";
+var DEFAULT_SERVER_URL = "http://localhost:8766";
+var EnvoyFileSchema = looseObject({
+  $schema: string2().optional(),
+  natsUrls: array(string2()).optional(),
+  dispatch: strictObject({
+    enabled: boolean2().optional(),
+    serverUrl: url().optional()
+  }).optional()
+});
+function describeSchemaIssue(filePath, error) {
+  const issue = error.issues[0];
+  if (!issue)
+    return `${filePath}: invalid dispatch config`;
+  if (issue.code === "unrecognized_keys") {
+    const keys = issue.keys.map((key) => `dispatch.${key}`).join(", ");
+    return `${filePath}: unrecognized dispatch key(s): ${keys}`;
+  }
+  return `${filePath}: ${issue.path.join(".")}: ${issue.message}`;
+}
+function readEnvoyFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(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 explicit = env["DISPATCH_MCP_URL"];
+  if (explicit)
+    return { url: explicit, error: null };
+  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 file of [userFile, repoFile]) {
+    if (file.kind === "invalid")
+      return { url: null, error: file.reason };
+  }
+  const merged = {
+    ...userFile.kind === "valid" ? userFile.settings : null,
+    ...repoFile.kind === "valid" ? repoFile.settings : null
+  };
+  if (merged.enabled !== true)
+    return { url: null, error: null };
+  const baseUrl = (merged.serverUrl ?? DEFAULT_SERVER_URL).replace(/\/+$/, "");
+  return { url: `${baseUrl}/mcp`, error: null };
+}
+
 // ../envoy-client/src/dispatch-subscribe.ts
 var ISSUE_URL_RE = /https?:\/\/github\.com\/([^/\s"]+)\/([^/\s"]+)\/issues\/(\d+)/i;
-var DISPATCH_TOOL_RE = /(^|[-._])dispatch$/i;
 function isDispatchTool(tool) {
-  return DISPATCH_TOOL_RE.test(tool);
+  return tool === DISPATCH_TOOL_NAME;
 }
 function dispatchThreadTopic(owner, repo, thread) {
   return `notifications.github.${owner}.${repo}.issue.${thread}.>`;
@@ -4692,12 +5421,6 @@ function dispatchSubscriptionTopic(tool, output) {
   return dispatchThreadTopic(owner, repo, thread);
 }
 
-// ../envoy-client/src/machine.ts
-import { hostname } from "os";
-function machineID() {
-  return process.env["ENVOY_MACHINE_ID"] || hostname();
-}
-
 // ../envoy-client/src/tool-contract.ts
 var EnvoyToolOperation = {
   subscribe: "subscribe",
@@ -4861,135 +5584,17 @@ function toEnvelope(value) {
 }
 
 // src/server.ts
-import { tool as tool2 } from "@opencode-ai/plugin/tool";
-
-// src/config/index.ts
-import { existsSync, readFileSync } from "fs";
-import os from "os";
-import path from "path";
-
-// ../envoy-client/src/errors.ts
-function messageFor(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// src/config/schema.ts
-import { tool } from "@opencode-ai/plugin";
-var z = tool.schema;
-var DispatchConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  serverUrl: z.string().url().optional()
-}).strict();
-var EnvoyConfigSchema = z.object({
-  $schema: z.string().optional(),
-  natsUrls: z.array(z.string()).optional(),
-  dispatch: DispatchConfigSchema.optional()
-}).passthrough();
-
-// src/config/index.ts
-class EnvoyConfigError extends Error {
-  filePath;
-  constructor(filePath, detail) {
-    super(`[envoy-plugin] invalid config at ${filePath}: ${detail}`);
-    this.name = "EnvoyConfigError";
-    this.filePath = filePath;
-  }
-}
-function readConfigFile(filePath) {
-  if (!existsSync(filePath))
-    return null;
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(filePath, "utf-8"));
-  } catch (error) {
-    throw new EnvoyConfigError(filePath, messageFor(error));
-  }
-  const parsed = EnvoyConfigSchema.safeParse(raw);
-  if (!parsed.success) {
-    const issues = parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
-    throw new EnvoyConfigError(filePath, issues);
-  }
-  return parsed.data;
-}
-function mergeConfig(base, override) {
-  return {
-    ...base,
-    ...override,
-    dispatch: base.dispatch || override.dispatch ? {
-      ...base.dispatch,
-      ...override.dispatch
-    } : undefined
-  };
-}
-async function loadEnvoyConfig(directory, options = {}) {
-  const homeDir = options.homeDir ?? os.homedir();
-  const userConfigPath = path.join(homeDir, ".config", "opencode", "envoy.json");
-  const repoConfigPath = path.join(directory, ".opencode", "envoy.json");
-  let merged = {};
-  const userConfig = readConfigFile(userConfigPath);
-  if (userConfig)
-    merged = mergeConfig(merged, userConfig);
-  const repoConfig = readConfigFile(repoConfigPath);
-  if (repoConfig)
-    merged = mergeConfig(merged, repoConfig);
-  return merged;
-}
-
-// src/dispatch-mcp.ts
-import { existsSync as existsSync2 } from "fs";
-import path2 from "path";
-var DEFAULT_SERVER_URL = "http://localhost:8766";
-function defaultShimPath() {
-  const packageRoot = path2.join(import.meta.dir, "..");
-  const candidates = [
-    path2.join(packageRoot, "bin", "dispatch-mcp-shim.js"),
-    path2.join(packageRoot, "bin", "dispatch-mcp-shim.ts")
-  ];
-  const found = candidates.find((candidate) => existsSync2(candidate));
-  if (!found) {
-    throw new Error(`dispatch MCP shim not found; tried: ${candidates.join(", ")}`);
-  }
-  return found;
-}
-function buildDispatchMcpEntry(opts) {
-  if (!opts.dispatch?.enabled)
-    return null;
-  const baseUrl = (opts.dispatch.serverUrl ?? DEFAULT_SERVER_URL).replace(/\/+$/, "");
-  const shimPath = opts.shimPath ?? defaultShimPath();
-  const runtime = opts.runtime ?? "bun";
-  return {
-    type: "local",
-    command: [runtime, shimPath],
-    environment: {
-      DISPATCH_MCP_URL: `${baseUrl}/mcp`
-    },
-    enabled: true
-  };
-}
-function injectEnvoyMcp(cfg, entry) {
-  cfg.mcp = cfg.mcp ?? {};
-  const existing = cfg.mcp.envoy;
-  if (existing !== undefined) {
-    if (JSON.stringify(existing) === JSON.stringify(entry)) {
-      return {};
-    }
-    return {
-      warning: "[envoy-plugin] envoy MCP entry already present in config; not overriding"
-    };
-  }
-  cfg.mcp.envoy = entry;
-  return {};
-}
+import { tool } from "@opencode-ai/plugin/tool";
 
 // src/log.ts
 import { appendFile, mkdir } from "fs/promises";
-import os2 from "os";
-import path3 from "path";
+import os from "os";
+import path2 from "path";
 function defaultLogDir() {
-  const home = os2.homedir();
+  const home = os.homedir();
   if (!home)
-    return path3.join(os2.tmpdir(), "opencode-log");
-  return path3.join(home, ".local", "share", "opencode", "log");
+    return path2.join(os.tmpdir(), "opencode-log");
+  return path2.join(home, ".local", "share", "opencode", "log");
 }
 function format(level, message) {
   return `${new Date().toISOString()} ${level} ${message}
@@ -4997,7 +5602,7 @@ function format(level, message) {
 }
 function createLogger(options = {}) {
   const dir = options.logDir ?? defaultLogDir();
-  const file = path3.join(dir, options.fileName ?? "envoy-plugin.log");
+  const file = path2.join(dir, options.fileName ?? "envoy-plugin.log");
   let chain = Promise.resolve();
   const append = (line) => {
     chain = chain.then(() => mkdir(dir, { recursive: true })).then(() => appendFile(file, line)).catch(() => {});
@@ -5020,7 +5625,7 @@ function createLogger(options = {}) {
 var logger = createLogger();
 
 // src/port.ts
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 
 // src/ss.ts
 function portFromSsOutput(output, pid) {
@@ -5042,15 +5647,15 @@ function portFromSsOutput(output, pid) {
 }
 
 // src/port.ts
-var defaultExec = (command, args, options) => new Promise((resolve, reject) => {
-  execFile(command, args, { encoding: options.encoding }, (error, stdout) => {
+var defaultExec2 = (command, args, options) => new Promise((resolve, reject) => {
+  execFile2(command, args, { encoding: options.encoding }, (error, stdout) => {
     if (error)
       reject(error);
     else
       resolve(stdout);
   });
 });
-async function resolvePort(serverUrl, exec = defaultExec) {
+async function resolvePort(serverUrl, exec = defaultExec2) {
   const urlPort = Number.parseInt(serverUrl.port, 10);
   if (Number.isFinite(urlPort) && urlPort > 0)
     return urlPort;
@@ -5064,11 +5669,11 @@ async function resolvePort(serverUrl, exec = defaultExec) {
 }
 
 // src/server.ts
-var moduleDirectory = path4.dirname(fileURLToPath(import.meta.url));
+var moduleDirectory = path3.dirname(fileURLToPath(import.meta.url));
 var skillsDirectory = [
-  path4.resolve(moduleDirectory, "../../skills"),
-  path4.resolve(moduleDirectory, "../../../skills")
-].find((dir) => existsSync3(dir));
+  path3.resolve(moduleDirectory, "../../skills"),
+  path3.resolve(moduleDirectory, "../../../skills")
+].find((dir) => existsSync(dir));
 var [
   subscribeSpec,
   unsubscribeSpec,
@@ -5079,9 +5684,33 @@ var [
   whoamiSpec,
   sessionsSpec
 ] = envoyToolSpecs;
+var dispatchQuestionOption = tool.schema.strictObject({
+  label: tool.schema.string().min(1),
+  description: tool.schema.string().optional()
+});
+var dispatchQuestion = tool.schema.strictObject({
+  question: tool.schema.string().min(1),
+  header: tool.schema.string().optional(),
+  options: tool.schema.array(dispatchQuestionOption).optional(),
+  multiple: tool.schema.boolean().optional(),
+  custom: tool.schema.boolean().optional()
+});
+var dispatchArgs = {
+  subject: tool.schema.string().describe(DISPATCH_ARGUMENTS.subject).optional(),
+  thread: tool.schema.string().describe(DISPATCH_ARGUMENTS.thread).optional(),
+  context: tool.schema.string().describe(DISPATCH_ARGUMENTS.context),
+  question: tool.schema.string().describe(DISPATCH_ARGUMENTS.question),
+  ask: tool.schema.array(dispatchQuestion).describe(DISPATCH_ARGUMENTS.ask).optional(),
+  urgency: tool.schema.enum(DISPATCH_URGENCIES).describe(DISPATCH_ARGUMENTS.urgency).optional(),
+  repo: tool.schema.string().describe(DISPATCH_ARGUMENTS.repo).optional(),
+  parent: tool.schema.string().describe(DISPATCH_ARGUMENTS.parent).optional()
+};
 var server_default = async (input) => {
   const cwd = process.cwd();
-  const config = await loadEnvoyConfig(cwd);
+  const dispatchConfig = resolveDispatchConfig(process.env, { cwd });
+  if (dispatchConfig.error !== null)
+    throw new Error(`[envoy-plugin] ${dispatchConfig.error}`);
+  const dispatchServiceUrl = dispatchConfig.url;
   const envoyDefaults = envoyDefaultsFromEnvironment(process.env);
   const envoy = createEnvoyClient({ baseUrl: envoyDefaults.envoyUrl, fetch: globalThis.fetch });
   let activeSessionID = null;
@@ -5152,6 +5781,25 @@ var server_default = async (input) => {
     clearInterval(timer);
     clearInterval(heartbeatInterval);
   });
+  const dispatchTool = dispatchServiceUrl === null ? {} : {
+    [DISPATCH_TOOL_NAME]: tool({
+      description: DISPATCH_TOOL_DESCRIPTION,
+      args: dispatchArgs,
+      async execute(args, ctx) {
+        ctx.metadata({ title: "Dispatch" });
+        const call = parseDispatchCall(args);
+        const result = await executeDispatch({
+          call,
+          cwd: ctx.directory,
+          host: "opencode",
+          sessionId: ctx.sessionID,
+          sessionTitle: await fetchTitle(ctx.sessionID) ?? undefined,
+          serviceUrl: dispatchServiceUrl
+        });
+        return JSON.stringify(result);
+      }
+    })
+  };
   return {
     config: (cfg) => {
       if (skillsDirectory) {
@@ -5161,14 +5809,6 @@ var server_default = async (input) => {
           cfg.skills.paths.push(skillsDirectory);
         }
       }
-      const entry = buildDispatchMcpEntry({
-        dispatch: config.dispatch
-      });
-      if (!entry)
-        return;
-      const { warning } = injectEnvoyMcp(cfg, entry);
-      if (warning)
-        logger.warn(warning);
     },
     event: async ({
       event
@@ -5242,9 +5882,10 @@ var server_default = async (input) => {
       clearInterval(heartbeatInterval);
     },
     tool: {
-      envoy_subscribe: tool2({
+      ...dispatchTool,
+      envoy_subscribe: tool({
         description: subscribeSpec.description,
-        args: { topics: tool2.schema.array(tool2.schema.string()) },
+        args: { topics: tool.schema.array(tool.schema.string()) },
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy subscribe" });
           return JSON.stringify(await envoy.subscribe({
@@ -5257,16 +5898,16 @@ var server_default = async (input) => {
           }));
         }
       }),
-      envoy_unsubscribe: tool2({
+      envoy_unsubscribe: tool({
         description: unsubscribeSpec.description,
-        args: { topics: tool2.schema.array(tool2.schema.string()).optional() },
+        args: { topics: tool.schema.array(tool.schema.string()).optional() },
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy unsubscribe" });
           await envoy.unsubscribe({ sessionID: ctx.sessionID, topics: args.topics ?? [] });
           return "ok";
         }
       }),
-      envoy_list: tool2({
+      envoy_list: tool({
         description: listSpec.description,
         args: {},
         async execute(_args, ctx) {
@@ -5274,9 +5915,9 @@ var server_default = async (input) => {
           return JSON.stringify(await envoy.getInterest(ctx.sessionID));
         }
       }),
-      envoy_send: tool2({
+      envoy_send: tool({
         description: sendSpec.description,
-        args: { session_id: tool2.schema.string(), message: tool2.schema.string() },
+        args: { session_id: tool.schema.string(), message: tool.schema.string() },
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy send" });
           return JSON.stringify(await envoy.send({
@@ -5286,9 +5927,9 @@ var server_default = async (input) => {
           }));
         }
       }),
-      envoy_publish: tool2({
+      envoy_publish: tool({
         description: publishSpec.description,
-        args: { topic: tool2.schema.string(), message: tool2.schema.string() },
+        args: { topic: tool.schema.string(), message: tool.schema.string() },
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy publish" });
           return JSON.stringify(await envoy.publish({
@@ -5298,15 +5939,15 @@ var server_default = async (input) => {
           }));
         }
       }),
-      envoy_role_set: tool2({
+      envoy_role_set: tool({
         description: roleSetSpec.description,
-        args: { role: tool2.schema.string() },
+        args: { role: tool.schema.string() },
         async execute(args, ctx) {
           ctx.metadata({ title: "Set Envoy role" });
           return JSON.stringify(await envoy.setRole({ sessionID: ctx.sessionID, role: args.role }));
         }
       }),
-      envoy_whoami: tool2({
+      envoy_whoami: tool({
         description: whoamiSpec.description,
         args: {},
         async execute(_args, ctx) {
@@ -5321,9 +5962,9 @@ var server_default = async (input) => {
           }, null, 2);
         }
       }),
-      envoy_sessions: tool2({
+      envoy_sessions: tool({
         description: sessionsSpec.description,
-        args: { machine: tool2.schema.string().optional() },
+        args: { machine: tool.schema.string().optional() },
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy sessions" });
           const sessions = await envoy.listSessions();