@sjawhar/opencode-legion-envoy 0.15.0 → 0.17.0

package/dist/src/server.js

@@ -19,6 +19,122 @@ import { existsSync } from "fs";
 import path3 from "path";
 import { fileURLToPath } from "url";
 
+// ../contracts/src/dispatch-tools.ts
+var ISSUE_REFERENCE = "An issue is a native KEY or external owner/repo#n reference; an external reference creates its native issue on first use when its repository is mapped in DISPATCH_REPO_PROJECTS.";
+var ASK_URGENCIES = ["low", "med", "high", "blocking"];
+var DOC_EDIT_OPS = ["replace", "delete", "insert"];
+var dispatchToolSpecs = [
+  {
+    name: "dispatch_issue",
+    description: "Create a native Dispatch issue for newly tracked work. Do not use it when an existing issue " + `already covers the work; read or update that issue instead. ${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      project: z.string().describe("Project key for the new issue."),
+      title: z.string().describe("Concise issue title."),
+      parent: z.string().describe("Optional parent issue.").optional(),
+      external: z.string().describe("Optional external issue reference.").optional(),
+      spec: z.string().describe("Optional initial primary-document markdown.").optional()
+    })
+  },
+  {
+    name: "dispatch_ask",
+    description: "Open a durable, answerable decision on an issue. Do not use it for a status update or discussion; " + `use dispatch_message instead. Question is at most 800 characters and has at most 8 options. ${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE),
+      question: z.string({ max: 800 }).describe("Decision question, at most 800 characters."),
+      options: z.array(z.object({
+        label: z.string().describe("Selectable option label."),
+        description: z.string().describe("Optional option context.").optional()
+      }), { max: 8 }).describe("Optional choices, at most 8.").optional(),
+      multiple: z.boolean().describe("Whether multiple choices may be selected.").optional(),
+      custom: z.boolean().describe("Whether a free-text answer is allowed.").optional(),
+      urgency: z.enum(ASK_URGENCIES).describe("Optional decision urgency.").optional(),
+      anchor: z.object({
+        artifact: z.string().describe("Artifact slug or id containing the quoted text."),
+        quote: z.string().describe("Exact text the decision concerns."),
+        occurrence: z.number({ int: true, min: 0 }).describe("Zero-based occurrence of the quote.").optional()
+      }).describe("Optional document location for the question.").optional()
+    })
+  },
+  {
+    name: "dispatch_comment",
+    description: "Add review feedback to an issue or document quote. Do not use it for an exact replacement; use " + `dispatch_suggest instead. Body is at most 2,000 characters. ${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE),
+      artifact: z.string().describe("Artifact slug or id required when quote is given.").optional(),
+      quote: z.string().describe("Optional exact quoted document text.").optional(),
+      occurrence: z.number({ int: true, min: 0 }).describe("Optional zero-based occurrence of quote.").optional(),
+      body: z.string({ max: 2000 }).describe("Review comment, at most 2,000 characters."),
+      reply_to: z.string().describe("Optional comment id to reply to.").optional()
+    })
+  },
+  {
+    name: "dispatch_suggest",
+    description: "Propose an exact replacement for quoted document text. Do not use it for general feedback; use " + `dispatch_comment instead. Optional explanation is at most 2,000 characters. ${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE),
+      artifact: z.string().describe("Artifact slug or id containing the quoted text."),
+      quote: z.string().describe("Exact document text to replace."),
+      replace_with: z.string().describe("Replacement text."),
+      body: z.string({ max: 2000 }).describe("Optional rationale, at most 2,000 characters.").optional(),
+      occurrence: z.number({ int: true, min: 0 }).describe("Optional zero-based occurrence of quote.").optional()
+    })
+  },
+  {
+    name: "dispatch_message",
+    description: "Post a plain issue update. Do not use it for a decision or line-specific review; use dispatch_ask " + `or dispatch_comment instead. Body is at most 2,000 characters. ${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE),
+      body: z.string({ max: 2000 }).describe("Update text, at most 2,000 characters.")
+    })
+  },
+  {
+    name: "dispatch_doc_edit",
+    description: "Apply deterministic text edits to a document. Do not use it for review feedback or for reading; use " + `dispatch_comment, dispatch_suggest, or dispatch_doc_read instead. ${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE),
+      artifact: z.string().describe("Artifact slug or id for the document."),
+      ops: z.array(z.object({
+        op: z.enum(DOC_EDIT_OPS).describe("Edit operation."),
+        find: z.string().describe("Text to find for replace or delete.").optional(),
+        with: z.string().describe("Replacement text for replace.").optional(),
+        occurrence: z.number({ int: true, min: 0 }).describe("Optional zero-based match occurrence.").optional(),
+        markdown: z.string().describe("Markdown to insert.").optional(),
+        after: z.string().describe("Anchor after which to insert.").optional(),
+        before: z.string().describe("Anchor before which to insert.").optional()
+      })).describe("Flat tagged edits; the server validates fields required for each operation."),
+      summary: z.string().describe("Optional named-version summary.").optional()
+    })
+  },
+  {
+    name: "dispatch_doc_read",
+    description: "Read a live document or a named document version. Do not use it for issue status, asks, or events; " + "use dispatch_read instead. Supply ref or issue; issue plus an omitted artifact reads the primary document. " + `${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE).optional(),
+      artifact: z.string().describe("Optional artifact slug or id; primary document by default.").optional(),
+      version: z.number({ int: true, min: 1 }).describe("Optional version number.").optional(),
+      ref: z.string().describe("Optional dispatch:// document reference.").optional()
+    })
+  },
+  {
+    name: "dispatch_artifact",
+    description: "Upload a local file as an issue artifact. Do not use it to edit a live document; use dispatch_doc_edit " + `instead. Files are limited to 25 MiB. ${ISSUE_REFERENCE}`,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE),
+      name: z.string().describe("Artifact filename shown in Dispatch."),
+      path: z.string().describe("Local path to the file to upload."),
+      primary: z.boolean().describe("Make this document the issue primary artifact.").optional(),
+      summary: z.string().describe("Optional version summary.").optional()
+    })
+  },
+  {
+    name: "dispatch_read",
+    description: "Read an issue summary, targeted ask, or targeted comment reply chain. Do not use it for document " + "contents; use dispatch_doc_read instead. Supply issue or ref. " + ISSUE_REFERENCE,
+    arguments: (z) => ({
+      issue: z.string().describe(ISSUE_REFERENCE).optional(),
+      ref: z.string().describe("Optional dispatch:// issue reference.").optional()
+    })
+  }
+];
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -13551,25 +13667,20 @@ function date4(params) {
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
 config(en_default());
-// ../contracts/src/dispatch-question.ts
-var DispatchQuestionOptionSchema = strictObject({
-  label: string2().min(1),
-  description: string2().optional()
-});
-var DispatchQuestionSchema = strictObject({
-  askId: string2().optional(),
-  question: string2().min(1),
-  header: string2().optional(),
-  options: array(DispatchQuestionOptionSchema).optional(),
-  multiple: boolean2().optional(),
-  custom: boolean2().optional()
-});
-var DispatchQuestionInputSchema = DispatchQuestionSchema.omit({ askId: true });
 // ../contracts/src/envelope.ts
 var isSubject = (value) => typeof value === "string" && value.length > 0;
 var EnvelopeSchema = object({
   event_id: string2().min(1),
-  source: _enum2(["agent", "human", "envoy", "github", "slack", "whatsapp", "ghostwispr"]),
+  source: _enum2([
+    "agent",
+    "human",
+    "envoy",
+    "github",
+    "slack",
+    "whatsapp",
+    "ghostwispr",
+    "dispatch"
+  ]),
   source_event_id: string2().min(1),
   source_session: string2().optional(),
   topic: custom(isSubject, { message: "topic must be a non-empty subject" }),
@@ -13831,6 +13942,13 @@ var LegionDaemonApi = {
     }),
     response: object({})
   },
+  PhaseComplete: {
+    request: strictObject({
+      grantId: nonEmptyString,
+      summary: nonEmptyString
+    }),
+    response: object({})
+  },
   SpawnWorker: {
     request: architectCapability.extend({
       issue: nonEmptyString,
@@ -13894,6 +14012,41 @@ var LegionDaemonApi = {
     response: object({ token: nonEmptyString, appLogin: string2().endsWith("[bot]") })
   }
 };
+// ../contracts/src/tool-schema.ts
+function zodSchemaApi(zod) {
+  const api = zod;
+  return {
+    string: (opts = {}) => {
+      let schema = api.string();
+      if (opts.min !== undefined)
+        schema = schema.min(opts.min);
+      if (opts.max !== undefined)
+        schema = schema.max(opts.max);
+      return schema;
+    },
+    number: (opts = {}) => {
+      let schema = api.number();
+      if (opts.int)
+        schema = schema.int();
+      if (opts.min !== undefined)
+        schema = schema.min(opts.min);
+      if (opts.max !== undefined)
+        schema = schema.max(opts.max);
+      return schema;
+    },
+    boolean: () => api.boolean(),
+    enum: (values) => api.enum(values),
+    array: (item, opts = {}) => {
+      let schema = api.array(item);
+      if (opts.min !== undefined)
+        schema = schema.min(opts.min);
+      if (opts.max !== undefined)
+        schema = schema.max(opts.max);
+      return schema;
+    },
+    object: (shape) => api.object(shape)
+  };
+}
 // ../envoy-client/src/defaults.ts
 var DEFAULT_ENVOY_URL = "http://127.0.0.1:9020";
 var DEFAULT_HEARTBEAT_MS = 120000;
@@ -13912,81 +14065,109 @@ 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 open issue in the repo; a plain work issue is adopted as a thread) 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 prose = {
-  context: string2(),
-  question: string2(),
-  ask: array(DispatchQuestionInputSchema).optional()
-};
-var OpenThreadCallSchema = strictObject({
-  subject: string2(),
-  ...prose,
-  urgency: _enum2(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(DispatchQuestionInputSchema).describe(DISPATCH_ARGUMENTS.ask).optional(),
-  urgency: _enum2(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;
+// ../envoy-client/src/dispatch-config.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import * as path from "path";
+
+// ../envoy-client/src/errors.ts
+function messageFor(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-function present(raw) {
-  return Object.fromEntries(Object.entries(raw).filter(([, value]) => value !== undefined));
+
+// ../envoy-client/src/dispatch-config.ts
+var DEFAULT_SERVER_URL = "http://localhost:8766";
+function normalizeDispatchUrl(url2) {
+  return url2.replace(/\/+$/, "");
 }
-function describeIssues(error) {
-  return error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+function deprecatedMcpUrl(url2) {
+  return normalizeDispatchUrl(url2).replace(/\/mcp$/, "");
 }
-function parseDispatchCall(raw) {
-  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-    throw new DispatchArgumentError("dispatch: invalid arguments \u2014 expected an object");
+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` };
   }
-  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");
+}
+var EnvoyFileSchema = looseObject({
+  $schema: string2().optional(),
+  natsUrls: array(string2()).optional(),
+  dispatch: strictObject({
+    enabled: boolean2().optional(),
+    serverUrl: url().optional(),
+    token: string2().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}`;
   }
-  if (!hasSubject && !hasThread) {
-    throw new DispatchArgumentError("dispatch: subject or thread is required");
+  return `${filePath}: ${issue.path.join(".")}: ${issue.message}`;
+}
+function readEnvoyFile(filePath) {
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch {
+    return { kind: "absent" };
   }
-  if (hasThread && (("urgency" in args) || ("repo" in args) || ("parent" in args))) {
-    throw new DispatchArgumentError("dispatch: thread cannot be combined with urgency, repo, or parent");
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(raw);
+  } catch (err) {
+    return { kind: "invalid", reason: `${filePath}: invalid JSON (${messageFor(err)})` };
   }
-  const parsed = hasThread ? ContinueThreadCallSchema.safeParse(args) : OpenThreadCallSchema.safeParse(args);
+  const parsed = EnvoyFileSchema.safeParse(parsedJson);
   if (!parsed.success) {
-    throw new DispatchArgumentError(`dispatch: invalid arguments \u2014 ${describeIssues(parsed.error)}`);
+    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 deprecatedUrl = explicitUrl ? undefined : env.DISPATCH_MCP_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 file of [userFile, repoFile]) {
+    if (file.kind === "invalid") {
+      return { enabled: false, url: null, token: null, error: file.reason };
+    }
+  }
+  const merged = {
+    ...userFile.kind === "valid" ? userFile.settings : null,
+    ...repoFile.kind === "valid" ? repoFile.settings : null
+  };
+  const rawUrl = explicitUrl !== undefined ? { value: explicitUrl, source: "DISPATCH_URL" } : deprecatedUrl !== undefined ? { value: deprecatedMcpUrl(deprecatedUrl), source: "DISPATCH_MCP_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 token = env.DISPATCH_TOKEN ?? merged.token ?? null;
+  const tokenSource = env.DISPATCH_TOKEN === undefined ? "dispatch.token" : "DISPATCH_TOKEN";
+  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 parsed.data;
+  return { enabled: true, url: url2.url, token, error: null };
 }
 
+// ../envoy-client/src/dispatch-execute.ts
+import { resolve as resolvePath } from "path";
+
 // ../envoy-client/src/dispatch-cwd.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -14069,229 +14250,592 @@ async function resolveOrigin(env, exec, cwd) {
   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;
-    }
-  };
-}
-
+// ../envoy-client/src/dispatch-http.ts
 class DispatchServiceError extends Error {
-  kind;
+  code;
+  status;
+  candidates;
   name = "DispatchServiceError";
-  constructor(kind, message) {
+  constructor(code, status, message, candidates) {
     super(message);
-    this.kind = kind;
+    this.code = code;
+    this.status = status;
+    this.candidates = candidates;
   }
 }
-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 asErrorShape(value) {
+  return typeof value === "object" && value !== null ? value : {};
 }
-function isDispatchServiceResult(value) {
-  return typeof value === "object" && value !== null && "thread" in value && typeof value.thread === "number" && "url" in value && typeof value.url === "string";
+function isJson(response) {
+  return response.headers.get("content-type")?.includes("application/json") ?? false;
 }
-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 }
-      })
+
+class DispatchClient {
+  token;
+  fetchImpl;
+  #baseUrl;
+  #resolvedIssues = new Map;
+  #creatingIssues = new Map;
+  constructor(baseUrl, token, fetchImpl = fetch) {
+    this.token = token;
+    this.fetchImpl = fetchImpl;
+    this.#baseUrl = baseUrl.replace(/\/+$/, "");
+  }
+  async issue(input) {
+    return this.#json("POST", ["api", "v1", "issues"], input);
+  }
+  async getIssue(issue) {
+    return this.#json("GET", ["api", "v1", "issues", await this.#resolveIssue(issue)]);
+  }
+  async getIssueEvents(issue, after = 0, limit = 200) {
+    return this.#json("GET", ["api", "v1", "issues", await this.#resolveIssue(issue), "events"], undefined, { after, limit });
+  }
+  async read(issueReference) {
+    const issueKey = await this.#resolveIssue(issueReference);
+    const issue = await this.getIssue(issueKey);
+    const events = await this.getIssueEvents(issueKey, Math.max(0, issue.last_seq - 10), 10);
+    return { issue, events };
+  }
+  async ask(issue, input) {
+    return this.#json("POST", ["api", "v1", "issues", await this.#resolveIssue(issue), "asks"], input);
+  }
+  async comment(issue, input) {
+    return this.#json("POST", ["api", "v1", "issues", await this.#resolveIssue(issue), "comments"], input);
+  }
+  async suggest(issue, input) {
+    const { replace_with, ...comment } = input;
+    return this.#json("POST", ["api", "v1", "issues", await this.#resolveIssue(issue), "comments"], {
+      ...comment,
+      suggestion: { replace_with }
     });
-  } 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)}`);
+  async message(issue, input) {
+    return this.#json("POST", ["api", "v1", "issues", await this.#resolveIssue(issue), "messages"], input);
   }
-  if (!response.ok) {
-    throw new DispatchServiceError("transport", `dispatch service returned ${response.status} ${response.statusText}: ${body.slice(0, 200)}`);
+  async artifact(issue, input) {
+    const form = new FormData;
+    form.set("name", input.name);
+    if (input.primary !== undefined)
+      form.set("primary", String(input.primary));
+    if (input.summary !== undefined)
+      form.set("summary", input.summary);
+    form.set("actor", JSON.stringify(input.actor));
+    form.set("file", input.file, input.name);
+    return this.#form("POST", ["api", "v1", "issues", await this.#resolveIssue(issue), "artifacts"], form);
   }
-  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)}`);
+  async getArtifact(id) {
+    return this.#json("GET", ["api", "v1", "artifacts", id]);
   }
-  const rpc = parsed ?? {};
-  if (rpc.error) {
-    throw new DispatchServiceError("tool", rpc.error.message ?? "dispatch service returned an error");
+  async docRead(id, version) {
+    return version === undefined ? this.#json("GET", ["api", "v1", "artifacts", id, "text"]) : this.#json("GET", ["api", "v1", "artifacts", id, "versions", String(version)]);
   }
-  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)}`);
+  async docEdit(id, input) {
+    return this.#json("POST", ["api", "v1", "artifacts", id, "edits"], input);
   }
-  if (!isDispatchServiceResult(result)) {
-    throw new DispatchServiceError("transport", `dispatch service result lacks thread/url: ${text.slice(0, 200)}`);
+  async nameArtifactVersion(id, input) {
+    return this.#json("POST", ["api", "v1", "artifacts", id, "versions"], input);
+  }
+  async getAsk(id) {
+    return this.#json("GET", ["api", "v1", "asks", id]);
+  }
+  async getComment(id) {
+    return this.#json("GET", ["api", "v1", "comments", id]);
+  }
+  async getComments(issue, artifact) {
+    return this.#json("GET", ["api", "v1", "issues", await this.#resolveIssue(issue), "comments"], undefined, artifact ? { artifact } : undefined);
+  }
+  async ensureIssue(issueReference, actor) {
+    if (!issueReference.includes("#"))
+      return issueReference;
+    try {
+      return await this.#resolveIssue(issueReference);
+    } catch (error) {
+      if (!(error instanceof DispatchServiceError) || error.status !== 404)
+        throw error;
+    }
+    let creating = this.#creatingIssues.get(issueReference);
+    if (!creating) {
+      creating = this.#createExternalIssue(issueReference, actor);
+      this.#creatingIssues.set(issueReference, creating);
+    }
+    try {
+      return await creating;
+    } finally {
+      if (this.#creatingIssues.get(issueReference) === creating) {
+        this.#creatingIssues.delete(issueReference);
+      }
+    }
+  }
+  async#createExternalIssue(issueReference, actor) {
+    try {
+      const created = await this.#json("POST", ["api", "v1", "issues"], {
+        external: issueReference,
+        actor
+      });
+      this.#resolvedIssues.set(issueReference, Promise.resolve(created.key));
+      return created.key;
+    } catch (error) {
+      if (error instanceof DispatchServiceError && (error.status === 409 || error.status === 500)) {
+        return this.#resolveIssue(issueReference);
+      }
+      throw error;
+    }
+  }
+  async#resolveIssue(issueReference) {
+    if (!issueReference.includes("#"))
+      return issueReference;
+    let resolved = this.#resolvedIssues.get(issueReference);
+    if (!resolved) {
+      resolved = this.#json("GET", ["api", "v1", "issues", "resolve"], undefined, {
+        ref: issueReference
+      }).then((resolution) => resolution.key);
+      this.#resolvedIssues.set(issueReference, resolved);
+    }
+    try {
+      return await resolved;
+    } catch (error) {
+      this.#resolvedIssues.delete(issueReference);
+      throw error;
+    }
+  }
+  async#json(method, path, body, query) {
+    const headers = {
+      Accept: "application/json",
+      Authorization: `Bearer ${this.token}`
+    };
+    if (body !== undefined)
+      headers["Content-Type"] = "application/json";
+    const response = await this.fetchImpl(this.#url(path, query), {
+      method,
+      headers,
+      ...body === undefined ? {} : { body: JSON.stringify(body) }
+    });
+    return this.#response(response);
+  }
+  async#form(method, path, body) {
+    const response = await this.fetchImpl(this.#url(path), {
+      method,
+      headers: { Accept: "application/json", Authorization: `Bearer ${this.token}` },
+      body
+    });
+    return this.#response(response);
+  }
+  #url(path, query) {
+    const url = new URL(`${path.map((segment) => encodeURIComponent(segment)).join("/")}`, `${this.#baseUrl}/`);
+    if (query) {
+      for (const [name, value] of Object.entries(query))
+        url.searchParams.set(name, String(value));
+    }
+    return url.toString();
+  }
+  async#response(response) {
+    const text = await response.text();
+    let payload = text;
+    if (text && isJson(response)) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        payload = text;
+      }
+    }
+    if (!response.ok) {
+      const error = asErrorShape(payload);
+      throw new DispatchServiceError(error.code ?? `HTTP_${response.status}`, response.status, error.error ?? (typeof payload === "string" && payload ? payload : response.statusText), error.candidates);
+    }
+    return payload;
   }
-  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 };
+// ../envoy-client/src/dispatch-execute.ts
+var nativeIssueKeyPattern = /^[A-Z][A-Z0-9]{1,9}-[0-9]+$/;
+var externalIssueRefPattern = /^([^/\s]+)\/([^/\s#]+)#([1-9][0-9]*)$/;
+var bareIssueNumberPattern = /^[1-9][0-9]*$/;
+function dispatchTopic(issue) {
+  return `notifications.dispatch.issue.${issue}.>`;
+}
+function stringArg(args, name) {
+  const value = args[name];
+  if (typeof value !== "string")
+    throw new Error(`${name} is required`);
+  return value;
 }
-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);
+function optionalString(args, name) {
+  const value = args[name];
+  return typeof value === "string" ? value : undefined;
 }
-
-// ../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}`;
+function optionalBoolean(args, name) {
+  const value = args[name];
+  return typeof value === "boolean" ? value : undefined;
+}
+function optionalNumber(args, name) {
+  const value = args[name];
+  return typeof value === "number" ? value : undefined;
+}
+function askUrgency(args) {
+  const value = args.urgency;
+  return ASK_URGENCIES.find((urgency) => urgency === value);
+}
+function parseDispatchRef(ref) {
+  const match = ref.match(/^dispatch:\/\/([A-Z][A-Z0-9]{1,9}-[1-9][0-9]*)(?:\/(spec)|\/artifact\/([^/@]+)(?:@v(\d+))?|\/ask\/([^/]+)|\/comment\/([^/]+))?$/);
+  if (!match)
+    return null;
+  const [, issue, spec, artifact, version, ask, comment] = match;
+  if (!issue || version !== undefined && Number(version) < 1)
+    return null;
+  if (spec)
+    return { issue, kind: "spec", id: spec };
+  if (artifact) {
+    return {
+      issue,
+      kind: "artifact",
+      id: artifact,
+      ...version === undefined ? {} : { version: Number(version) }
+    };
   }
-  return `${filePath}: ${issue.path.join(".")}: ${issue.message}`;
+  if (ask)
+    return { issue, kind: "ask", id: ask };
+  if (comment)
+    return { issue, kind: "comment", id: comment };
+  return { issue, kind: "issue", id: issue };
+}
+function toolSchema(tool) {
+  const spec = dispatchToolSpecs.find((candidate) => candidate.name === tool);
+  if (!spec)
+    throw new Error(`Unknown Dispatch tool: ${tool}`);
+  return object(spec.arguments(zodSchemaApi(exports_external))).strict();
+}
+async function resolveIssueArguments(tool, args, cwd, env, exec) {
+  if (tool === "dispatch_issue")
+    return { args, ref: null };
+  const refArgument = args.ref;
+  const ref = typeof refArgument === "string" ? parseDispatchRef(refArgument) ?? (() => {
+    throw new Error("ref must be a valid dispatch:// reference");
+  })() : null;
+  const issueArgument = args.issue;
+  const artifactArgument = args.artifact;
+  const versionArgument = args.version;
+  if (issueArgument !== undefined || ref !== null) {
+    return {
+      args: {
+        ...args,
+        ...issueArgument === undefined && ref?.issue !== undefined ? { issue: ref.issue } : {},
+        ...artifactArgument === undefined && (ref?.kind === "spec" || ref?.kind === "artifact") ? { artifact: ref.id } : {},
+        ...versionArgument === undefined && ref?.version !== undefined ? { version: ref.version } : {}
+      },
+      ref
+    };
+  }
+  const legionIssue = env.LEGION_ISSUE;
+  if (!legionIssue)
+    throw new Error("issue is required; supply issue or set LEGION_ISSUE");
+  if (nativeIssueKeyPattern.test(legionIssue) || externalIssueRefPattern.test(legionIssue)) {
+    return { args: { ...args, issue: legionIssue }, ref: null };
+  }
+  if (!bareIssueNumberPattern.test(legionIssue)) {
+    throw new Error("LEGION_ISSUE must be a native issue key (e.g. LEGION-3), an external owner/repo#n reference, or a bare positive issue number");
+  }
+  const repo = await resolveCwdRepo(cwd, exec);
+  if (!repo)
+    throw new Error("issue is required; LEGION_ISSUE needs a GitHub repository in cwd");
+  return { args: { ...args, issue: `${repo}#${legionIssue}` }, ref: null };
 }
-function readEnvoyFile(filePath) {
-  let raw;
-  try {
-    raw = readFileSync(filePath, "utf-8");
-  } catch {
-    return { kind: "absent" };
+async function resolveArtifact(client, issueReference, artifactReference) {
+  const issue = await client.getIssue(issueReference);
+  const artifact = artifactReference === undefined || artifactReference === "spec" ? issue.artifacts.find((candidate) => candidate.primary || candidate.id === issue.primary_artifact_id) : issue.artifacts.find((candidate) => candidate.id === artifactReference || candidate.slug === artifactReference);
+  if (!artifact) {
+    throw new Error(`artifact ${artifactReference ?? "spec"} was not found on issue ${issue.key}`);
   }
-  let parsedJson;
+  return { issue, artifact };
+}
+function anchor(artifact, args) {
+  const quote = optionalString(args, "quote");
+  if (quote === undefined)
+    return;
+  const occurrence = optionalNumber(args, "occurrence");
+  return { artifact: artifact.id, quote, ...occurrence === undefined ? {} : { occurrence } };
+}
+function toolActor(origin, input) {
+  return {
+    kind: "session",
+    id: input.sessionId ?? "unknown",
+    origin: {
+      ...origin,
+      host: input.host,
+      ...input.sessionTitle === undefined ? {} : { session_title: input.sessionTitle }
+    }
+  };
+}
+function issueSummary(issue, events) {
+  const asks = issue.open_asks;
+  return [
+    `Title: ${issue.title}`,
+    `Key: ${issue.key}`,
+    `Status: ${issue.status}`,
+    `Route: ${issue.route ?? "none"}`,
+    "Open asks:",
+    ...asks.length === 0 ? ["- none"] : asks.map((ask) => `- ${ask.id}: ${ask.question}`),
+    "Events:",
+    ...events.length === 0 ? ["- none"] : events.map((event) => `- #${event.seq} ${event.type} \xB7 ${event.actor.kind} ${event.actor.id} \xB7 ${event.created_at}`)
+  ].join(`
+`);
+}
+function askSummary(ask) {
+  const answer = ask.answer;
+  return [
+    `Question: ${ask.question}`,
+    "Options:",
+    ...ask.options.length === 0 ? ["- none"] : ask.options.map((option) => `- ${option.label}${option.description ? ` \u2014 ${option.description}` : ""}`),
+    `State: ${ask.state}`,
+    "Answer:",
+    ...answer === null ? ["- none"] : [
+      `- By: ${answer.user}`,
+      `- Selected: ${answer.selected.length === 0 ? "none" : answer.selected.join(", ")}`,
+      ...answer.text === null ? [] : [`- Text: ${answer.text}`]
+    ]
+  ].join(`
+`);
+}
+function commentSummary({ comment, replies }) {
+  const root = [
+    `${comment.id} \xB7 ${comment.author.kind} ${comment.author.id}`,
+    ...comment.anchor?.quote === undefined ? [] : [`> ${comment.anchor.quote}`],
+    `Body: ${comment.body}`
+  ];
+  const chain = replies.flatMap((reply) => [
+    `${reply.id} \xB7 ${reply.author.kind} ${reply.author.id}`,
+    ...reply.anchor?.quote === undefined ? [] : [`> ${reply.anchor.quote}`],
+    `Body: ${reply.body}`
+  ]);
+  return ["Comment:", ...root, "Reply chain:", ...chain.length === 0 ? ["- none"] : chain].join(`
+`);
+}
+async function openArtifactMarks(client, resolved) {
+  const marks = resolved.issue.open_asks.filter((ask) => ask.state === "open" && ask.anchor?.artifact_id === resolved.artifact.id).map((ask) => `ask ${ask.id}`);
+  let comments;
   try {
-    parsedJson = JSON.parse(raw);
-  } catch (err) {
-    return { kind: "invalid", reason: `${filePath}: invalid JSON (${messageFor(err)})` };
+    comments = await client.getComments(resolved.issue.key, resolved.artifact.id);
+  } catch (error) {
+    if (error instanceof DispatchServiceError && error.status === 404)
+      return marks;
+    throw error;
   }
-  const parsed = EnvoyFileSchema.safeParse(parsedJson);
-  if (!parsed.success) {
-    return { kind: "invalid", reason: describeSchemaIssue(filePath, parsed.error) };
+  return [
+    ...marks,
+    ...comments.filter((comment) => !comment.resolved && comment.anchor?.artifact_id === resolved.artifact.id).map((comment) => `comment ${comment.id}`)
+  ];
+}
+async function executeDispatchTool(input) {
+  if (!input.config.enabled || !input.config.url || !input.config.token) {
+    throw new Error("Dispatch is disabled; resolve both DISPATCH_URL and DISPATCH_TOKEN");
+  }
+  const env = input.env ?? process.env;
+  const exec = input.exec ?? defaultExec;
+  const issueArguments = await resolveIssueArguments(input.tool, input.args, input.cwd, env, exec);
+  const args = toolSchema(input.tool).parse(issueArguments.args);
+  const actor = toolActor(await resolveOrigin(env, exec, input.cwd), input);
+  const client = new DispatchClient(input.config.url, input.config.token, input.fetchImpl);
+  const issueKey = input.tool === "dispatch_issue" ? null : await ensureIssue(client, stringArg(args, "issue"), actor);
+  const issue = () => {
+    if (issueKey === null)
+      throw new Error("issue is required");
+    return issueKey;
+  };
+  switch (input.tool) {
+    case "dispatch_issue": {
+      const parent = optionalString(args, "parent");
+      const external = optionalString(args, "external");
+      const spec = optionalString(args, "spec");
+      const created = await client.issue({
+        project: stringArg(args, "project"),
+        title: stringArg(args, "title"),
+        ...parent === undefined ? {} : { parent },
+        ...external === undefined ? {} : { external },
+        ...spec === undefined ? {} : { spec },
+        actor
+      });
+      return {
+        text: `Created ${created.key}: ${created.title}`,
+        details: { issue: created.key, topic: dispatchTopic(created.key) }
+      };
+    }
+    case "dispatch_ask": {
+      const anchorArgs = asObject(args.anchor);
+      const resolved = anchorArgs ? await resolveArtifact(client, issue(), stringArg(anchorArgs, "artifact")) : undefined;
+      const options = args.options;
+      const multiple = optionalBoolean(args, "multiple");
+      const custom = optionalBoolean(args, "custom");
+      const urgency = askUrgency(args);
+      const anchored = anchorArgs && resolved ? anchor(resolved.artifact, anchorArgs) : undefined;
+      const ask = await client.ask(issue(), {
+        question: stringArg(args, "question"),
+        ...Array.isArray(options) ? { options } : {},
+        ...multiple === undefined ? {} : { multiple },
+        ...custom === undefined ? {} : { custom },
+        ...urgency === undefined ? {} : { urgency },
+        ...anchored === undefined ? {} : { anchor: anchored },
+        actor
+      });
+      return {
+        text: `Opened ask ${ask.id}: ${ask.question}`,
+        details: { issue: ask.issue_key, topic: dispatchTopic(ask.issue_key), ask: ask.id }
+      };
+    }
+    case "dispatch_comment": {
+      const artifactReference = optionalString(args, "artifact");
+      if (optionalString(args, "quote") !== undefined && artifactReference === undefined) {
+        throw new Error("artifact is required when quote is supplied");
+      }
+      const resolved = artifactReference ? await resolveArtifact(client, issue(), artifactReference) : undefined;
+      const anchored = resolved ? anchor(resolved.artifact, args) : undefined;
+      const replyTo = optionalString(args, "reply_to");
+      const comment = await client.comment(issue(), {
+        body: stringArg(args, "body"),
+        ...anchored === undefined ? {} : { anchor: anchored },
+        ...replyTo === undefined ? {} : { reply_to: replyTo },
+        actor
+      });
+      return {
+        text: `Posted comment ${comment.id}`,
+        details: {
+          issue: comment.issue_key,
+          topic: dispatchTopic(comment.issue_key),
+          comment: comment.id
+        }
+      };
+    }
+    case "dispatch_suggest": {
+      const resolved = await resolveArtifact(client, issue(), stringArg(args, "artifact"));
+      const anchored = anchor(resolved.artifact, args);
+      if (anchored === undefined)
+        throw new Error("quote is required");
+      const body = optionalString(args, "body");
+      const comment = await client.suggest(issue(), {
+        ...body === undefined ? {} : { body },
+        anchor: anchored,
+        replace_with: stringArg(args, "replace_with"),
+        actor
+      });
+      return {
+        text: `Posted suggestion ${comment.id}`,
+        details: {
+          issue: comment.issue_key,
+          topic: dispatchTopic(comment.issue_key),
+          comment: comment.id
+        }
+      };
+    }
+    case "dispatch_message": {
+      const message = await client.message(issue(), { body: stringArg(args, "body"), actor });
+      return {
+        text: `Posted message ${message.id}`,
+        details: {
+          issue: message.issue_key,
+          topic: dispatchTopic(message.issue_key),
+          message: message.id
+        }
+      };
+    }
+    case "dispatch_doc_edit": {
+      const resolved = await resolveArtifact(client, issue(), stringArg(args, "artifact"));
+      const ops = args.ops;
+      const summary = optionalString(args, "summary");
+      const edited = await client.docEdit(resolved.artifact.id, {
+        ops,
+        ...summary === undefined ? {} : { summary },
+        actor
+      });
+      return {
+        text: edited.version === null ? `Applied ${edited.applied} ops (no new version)` : `Applied ${edited.applied} ops (version ${edited.version.number})`,
+        details: {
+          issue: resolved.issue.key,
+          topic: dispatchTopic(resolved.issue.key),
+          applied: edited.applied,
+          ...edited.version === null ? {} : { version: edited.version.number }
+        }
+      };
+    }
+    case "dispatch_doc_read": {
+      const artifactReference = optionalString(args, "artifact") ?? (issueArguments.ref?.kind === "spec" || issueArguments.ref?.kind === "artifact" ? issueArguments.ref.id : undefined);
+      const resolved = await resolveArtifact(client, issue(), artifactReference);
+      const version = optionalNumber(args, "version") ?? issueArguments.ref?.version;
+      const document = await client.docRead(resolved.artifact.id, version);
+      const marks = await openArtifactMarks(client, resolved);
+      return {
+        text: marks.length === 0 ? document.markdown : `${document.markdown}
+
+Open anchored asks/comments: ${marks.join(", ")}`,
+        details: { issue: resolved.issue.key, topic: dispatchTopic(resolved.issue.key) }
+      };
+    }
+    case "dispatch_artifact": {
+      const primary = optionalBoolean(args, "primary");
+      const summary = optionalString(args, "summary");
+      const result = await client.artifact(issue(), {
+        name: stringArg(args, "name"),
+        file: Bun.file(resolvePath(input.cwd, stringArg(args, "path"))),
+        ...primary === undefined ? {} : { primary },
+        ...summary === undefined ? {} : { summary },
+        actor
+      });
+      return {
+        text: `Uploaded ${result.artifact.name} as version ${result.version.number}`,
+        details: {
+          issue: result.artifact.issue_key,
+          topic: dispatchTopic(result.artifact.issue_key),
+          artifact: result.artifact.id,
+          version: result.version.number
+        }
+      };
+    }
+    case "dispatch_read": {
+      if (issueArguments.ref?.kind === "ask") {
+        const ask = await client.getAsk(issueArguments.ref.id);
+        return {
+          text: askSummary(ask),
+          details: { issue: ask.issue_key, topic: dispatchTopic(ask.issue_key) }
+        };
+      }
+      if (issueArguments.ref?.kind === "comment") {
+        const comment = await client.getComment(issueArguments.ref.id);
+        return {
+          text: commentSummary(comment),
+          details: {
+            issue: comment.comment.issue_key,
+            topic: dispatchTopic(comment.comment.issue_key)
+          }
+        };
+      }
+      const read = await client.read(issue());
+      return {
+        text: issueSummary(read.issue, read.events),
+        details: { issue: read.issue.key, topic: dispatchTopic(read.issue.key) }
+      };
+    }
+    default:
+      throw new Error(`Unknown Dispatch tool: ${input.tool}`);
   }
-  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 };
+async function ensureIssue(client, issueReference, actor) {
+  try {
+    return await client.ensureIssue(issueReference, actor);
+  } catch (error) {
+    if (error instanceof DispatchServiceError && error.code === "PROJECT_UNMAPPED") {
+      const repository = issueReference.slice(0, issueReference.lastIndexOf("#"));
+      throw new Error(`repository ${repository} is not mapped in DISPATCH_REPO_PROJECTS`);
+    }
+    throw error;
   }
-  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 };
+}
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 
 // ../envoy-client/src/dispatch-subscribe.ts
-var ISSUE_URL_RE = /https?:\/\/github\.com\/([^/\s"]+)\/([^/\s"]+)\/issues\/(\d+)/i;
-function isDispatchTool(tool) {
-  return tool === DISPATCH_TOOL_NAME;
-}
-function dispatchThreadTopic(owner, repo, thread) {
-  return `notifications.github.${owner}.${repo}.issue.${thread}.>`;
-}
-function dispatchSubscriptionTopic(tool, output) {
-  if (!isDispatchTool(tool))
-    return null;
-  const match = ISSUE_URL_RE.exec(output);
-  if (!match)
-    return null;
-  const owner = match[1];
-  const repo = match[2];
-  const thread = Number(match[3]);
-  if (!Number.isInteger(thread) || thread <= 0)
+function dispatchSubscriptionTopic(details) {
+  if (typeof details !== "object" || details === null || !("topic" in details))
     return null;
-  return dispatchThreadTopic(owner, repo, thread);
+  const { topic } = details;
+  return typeof topic === "string" && topic.startsWith("notifications.dispatch.") ? topic : null;
 }
 
 // ../envoy-client/src/tool-contract.ts
@@ -14305,10 +14849,19 @@ function messageMetadataShape(schema) {
     supersedes: schema.string().optional(),
     urgency: schema.enum(URGENCY_VALUES).optional(),
     expects_reply: schema.enum(EXPECTS_REPLY_VALUES).optional(),
-    expires_at: schema.number().int().optional()
+    expires_at: schema.number({ int: true }).optional()
+  };
+}
+var MessageMetadataSchema = object(messageMetadataShape(zodSchemaApi(exports_external)));
+function toMessageMetadata(args) {
+  return {
+    ...args.in_reply_to === undefined ? {} : { inReplyTo: args.in_reply_to },
+    ...args.supersedes === undefined ? {} : { supersedes: args.supersedes },
+    ...args.urgency === undefined ? {} : { urgency: args.urgency },
+    ...args.expects_reply === undefined ? {} : { expectsReply: args.expects_reply },
+    ...args.expires_at === undefined ? {} : { expiresAt: args.expires_at }
   };
 }
-var MessageMetadataSchema = object(messageMetadataShape(exports_external));
 function messageArguments(schema) {
   return { message: schema.string(), ...messageMetadataShape(schema) };
 }
@@ -14698,33 +15251,12 @@ var publishSpec = toolSpec("envoy_publish");
 var roleSetSpec = toolSpec("envoy_role_set");
 var whoamiSpec = toolSpec("envoy_whoami");
 var sessionsSpec = toolSpec("envoy_sessions");
-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 dispatchConfig = resolveDispatchConfig(process.env, { cwd });
-  if (dispatchConfig.error !== null)
-    throw new Error(`[envoy-plugin] ${dispatchConfig.error}`);
-  const dispatchServiceUrl = dispatchConfig.url;
+  if (!dispatchConfig.enabled) {
+    logger.warn(`envoy: dispatch tools disabled \u2014 ${dispatchConfig.error ?? "no Dispatch URL configured"}`);
+  }
   const envoyDefaults = envoyDefaultsFromEnvironment(process.env);
   const envoy = createEnvoyClient({ baseUrl: envoyDefaults.envoyUrl, fetch: globalThis.fetch });
   let activeSessionID = null;
@@ -14795,25 +15327,29 @@ 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);
-      }
-    })
-  };
+  const dispatchTools = {};
+  if (dispatchConfig.enabled) {
+    for (const spec of dispatchToolSpecs) {
+      dispatchTools[spec.name] = tool({
+        description: spec.description,
+        args: spec.arguments(zodSchemaApi(tool.schema)),
+        async execute(args, ctx) {
+          ctx.metadata({ title: "Dispatch" });
+          const result = await executeDispatchTool({
+            tool: spec.name,
+            args,
+            cwd: ctx.directory,
+            host: "opencode",
+            sessionId: ctx.sessionID,
+            sessionTitle: await fetchTitle(ctx.sessionID) ?? undefined,
+            config: dispatchConfig,
+            env: process.env
+          });
+          return { title: "Dispatch", output: result.text, metadata: result.details };
+        }
+      });
+    }
+  }
   return {
     config: (cfg) => {
       if (skillsDirectory) {
@@ -14874,7 +15410,7 @@ var server_default = async (input) => {
       }
     },
     "tool.execute.after": async (input, output) => {
-      const topic = dispatchSubscriptionTopic(input.tool, output.output);
+      const topic = dispatchSubscriptionTopic(output.metadata);
       if (!topic)
         return;
       try {
@@ -14896,10 +15432,10 @@ var server_default = async (input) => {
       clearInterval(heartbeatInterval);
     },
     tool: {
-      ...dispatchTool,
+      ...dispatchTools,
       envoy_subscribe: tool({
         description: subscribeSpec.description,
-        args: { topics: tool.schema.array(tool.schema.string()) },
+        args: subscribeSpec.arguments(zodSchemaApi(tool.schema)),
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy subscribe" });
           return JSON.stringify(await envoy.subscribe({
@@ -14914,16 +15450,19 @@ var server_default = async (input) => {
       }),
       envoy_unsubscribe: tool({
         description: unsubscribeSpec.description,
-        args: { topics: tool.schema.array(tool.schema.string()).optional() },
+        args: unsubscribeSpec.arguments(zodSchemaApi(tool.schema)),
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy unsubscribe" });
-          await envoy.unsubscribe({ sessionID: ctx.sessionID, topics: args.topics ?? [] });
+          await envoy.unsubscribe({
+            sessionID: ctx.sessionID,
+            topics: args.topics ?? []
+          });
           return "ok";
         }
       }),
       envoy_list: tool({
         description: listSpec.description,
-        args: {},
+        args: listSpec.arguments(zodSchemaApi(tool.schema)),
         async execute(_args, ctx) {
           ctx.metadata({ title: "Envoy list" });
           return JSON.stringify(await envoy.getInterest(ctx.sessionID));
@@ -14931,31 +15470,33 @@ var server_default = async (input) => {
       }),
       envoy_send: tool({
         description: sendSpec.description,
-        args: { session_id: tool.schema.string(), message: tool.schema.string() },
+        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
+            message: args.message,
+            ...toMessageMetadata(args)
           }));
         }
       }),
       envoy_publish: tool({
         description: publishSpec.description,
-        args: { topic: tool.schema.string(), message: tool.schema.string() },
+        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
+            message: args.message,
+            ...toMessageMetadata(args)
           }));
         }
       }),
       envoy_role_set: tool({
         description: roleSetSpec.description,
-        args: { role: tool.schema.string() },
+        args: roleSetSpec.arguments(zodSchemaApi(tool.schema)),
         async execute(args, ctx) {
           ctx.metadata({ title: "Set Envoy role" });
           return JSON.stringify(await envoy.setRole({ sessionID: ctx.sessionID, role: args.role }));
@@ -14963,7 +15504,7 @@ var server_default = async (input) => {
       }),
       envoy_whoami: tool({
         description: whoamiSpec.description,
-        args: {},
+        args: whoamiSpec.arguments(zodSchemaApi(tool.schema)),
         async execute(_args, ctx) {
           ctx.metadata({ title: "Envoy whoami" });
           const sessionID = ctx.sessionID;
@@ -14978,11 +15519,15 @@ var server_default = async (input) => {
       }),
       envoy_sessions: tool({
         description: sessionsSpec.description,
-        args: { machine: tool.schema.string().optional() },
+        args: sessionsSpec.arguments(zodSchemaApi(tool.schema)),
         async execute(args, ctx) {
           ctx.metadata({ title: "Envoy sessions" });
-          const sessions = await envoy.listSessions();
-          return JSON.stringify(args.machine ? sessions.filter((session) => session.machine_id === args.machine) : sessions, null, 2);
+          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);
         }
       })
     }