@sjawhar/opencode-legion-envoy 12.2.0 → 12.3.0

package/dist/dispatch.js

@@ -1243,6 +1243,667 @@ function consumeMarker(stores, argv, args, files, now) {
   };
 }
 
+// ../envoy-client/src/askgate-new-asks.ts
+var OPENING_CODE_POINTS = 60;
+function newAsks(toolName, input) {
+  switch (toolName) {
+    case "dispatch_ask":
+      return [questionAsk(input)];
+    case "dispatch_issue":
+      return typeof input.spec === "string" ? askBlocks(input.spec) : [];
+    case "dispatch_artifact":
+      return typeof input.content === "string" ? askBlocks(input.content) : [];
+    case "dispatch_doc_edit":
+      return (Array.isArray(input.ops) ? input.ops : []).flatMap((op) => {
+        if (typeof op !== "object" || op === null)
+          return [];
+        const { op: kind, markdown, type, block } = op;
+        if (kind === "insert" && typeof markdown === "string") {
+          const { before, after } = op;
+          return scanAsks(markdown, before === "start" || after === "start");
+        }
+        if (kind === "retype" && type === "ask" && typeof block === "string") {
+          return [{ kind: "retype", id: block, text: "", opening: "" }];
+        }
+        return [];
+      });
+    default:
+      return [];
+  }
+}
+function questionAsk(input) {
+  const question = typeof input.question === "string" ? input.question.trim() : "";
+  const options = (Array.isArray(input.options) ? input.options : []).flatMap((option) => {
+    if (typeof option !== "object" || option === null)
+      return [];
+    const { label, description } = option;
+    return [
+      typeof description === "string" && description !== "" ? `- ${String(label ?? "")}: ${description}` : `- ${String(label ?? "")}`
+    ];
+  });
+  return {
+    kind: "ask",
+    text: options.length === 0 ? question : `${question}
+
+${options.join(`
+`)}`,
+    opening: openingOf(question)
+  };
+}
+function openingOf(text) {
+  return Array.from(text.replace(/\s+/g, " ").trim()).slice(0, OPENING_CODE_POINTS).join("");
+}
+var FRONT_MATTER_FENCE = /^---[ \t]*$/;
+function askBlocks(markdown) {
+  return scanAsks(markdown, true);
+}
+function scanAsks(markdown, frontMatter) {
+  let lines = markdown.replace(/\r\n?/g, `
+`).split(`
+`);
+  let unclosedFrontMatter = false;
+  if (frontMatter && FRONT_MATTER_FENCE.test(lines[0] ?? "")) {
+    const close = lines.findIndex((line, index) => index > 0 && FRONT_MATTER_FENCE.test(line));
+    if (close === -1)
+      unclosedFrontMatter = true;
+    else
+      lines = lines.slice(close + 1);
+  }
+  const scan = {
+    lines,
+    index: 0,
+    opened: [],
+    drafts: [],
+    emptyItemWithBlankLines: false,
+    skipList: false,
+    unclosedFrontMatter
+  };
+  const document = {
+    kind: "document",
+    parent: undefined,
+    previous: undefined,
+    children: 0,
+    last: undefined
+  };
+  for (const [index, text] of lines.entries()) {
+    scan.index = index;
+    readLine(scan, document, new Line(text));
+  }
+  return scan.drafts.map(({ id, lines: body }) => {
+    const text = body.join(`
+`).trim();
+    return { kind: "block", ...id === undefined ? {} : { id }, text, opening: openingOf(text) };
+  });
+}
+
+class Line {
+  text;
+  #starts;
+  #pos = 0;
+  #column = 0;
+  constructor(text) {
+    this.text = text;
+    const starts = [0];
+    let column = 0;
+    for (let index = 0;index < text.length; index++) {
+      column += text[index] === "\t" ? 4 - column % 4 : 1;
+      starts.push(column);
+    }
+    this.#starts = starts;
+  }
+  get column() {
+    return this.#column;
+  }
+  columnAt(index) {
+    return this.#starts[index];
+  }
+  #afterSpaces(index) {
+    let end = index;
+    while (end < this.text.length && (this.text[end] === " " || this.text[end] === "\t"))
+      end++;
+    return end;
+  }
+  spacesAt(index) {
+    return this.columnAt(this.#afterSpaces(index)) - this.columnAt(index);
+  }
+  indent() {
+    const at = this.#afterSpaces(this.#pos);
+    return { width: this.columnAt(at) - this.#column, at };
+  }
+  blank() {
+    return this.indent().at === this.text.length;
+  }
+  skip(columns) {
+    this.#column += columns;
+    while (this.#pos < this.text.length && this.columnAt(this.#pos + 1) <= this.#column)
+      this.#pos++;
+  }
+  advanceTo(index) {
+    this.#pos = index;
+    this.#column = this.columnAt(index);
+  }
+  rest() {
+    const start = this.columnAt(this.#pos);
+    if (this.#pos < this.text.length && start < this.#column) {
+      return " ".repeat(this.columnAt(this.#pos + 1) - this.#column) + this.text.slice(this.#pos + 1);
+    }
+    return this.text.slice(this.#pos);
+  }
+}
+function readLine(scan, document, line) {
+  if (scan.opened.length === 0) {
+    if (!line.blank())
+      openBlocks(scan, document, line);
+    return;
+  }
+  const opened = [...scan.opened];
+  const lastIndex = opened.length - 1;
+  for (const [index, block] of opened.entries()) {
+    if (block.kind !== "paragraph") {
+      const continuation = continueBlock(scan, block, line);
+      if (continuation === "children" && index === lastIndex) {
+        openBlocks(scan, block, line);
+        return;
+      }
+      if (continuation !== "close")
+        continue;
+    }
+    if (openBlocks(scan, opened[index - 1] ?? document, line) !== "paragraph") {
+      scan.opened.splice(index, lastIndex - index + 1);
+    }
+    return;
+  }
+}
+function openBlocks(scan, parent, line) {
+  const continuable = scan.opened.at(-1)?.kind === "paragraph";
+  let result = "none";
+  for (let into = parent;; ) {
+    const { width, at } = line.indent();
+    if (at === line.text.length)
+      break;
+    const char = line.text.charAt(at);
+    const interrupting = continuable && result === "none";
+    let opened;
+    for (const parser of BLOCK_PARSERS) {
+      if (parser.triggers !== undefined && !parser.triggers.includes(char))
+        continue;
+      if (interrupting && !parser.interrupts)
+        continue;
+      if (width > 3 && !parser.indented)
+        continue;
+      opened = parser.open(scan, into, line, width, at);
+      if (opened !== undefined)
+        break;
+    }
+    if (opened === undefined)
+      break;
+    into.children++;
+    into.last = opened.block;
+    scan.opened.push(opened.block);
+    result = "opened";
+    if (!opened.children)
+      break;
+    into = opened.block;
+  }
+  const last = scan.opened.at(-1);
+  if (result === "none" && last?.kind === "paragraph" && !line.blank()) {
+    last.rows.push(line.rest());
+    last.lastLine = scan.index;
+    line.advanceTo(line.text.length);
+    return "paragraph";
+  }
+  return result;
+}
+function under(parent) {
+  return { parent, previous: parent.last, children: 0, last: undefined };
+}
+function leafAt(parent, line) {
+  line.advanceTo(line.text.length);
+  return { block: { kind: "leaf", ...under(parent) }, children: false };
+}
+function frontMatterHolds(scan, parent) {
+  return scan.unclosedFrontMatter && parent.kind === "document";
+}
+var BLOCK_PARSERS = [
+  {
+    triggers: "-=",
+    interrupts: true,
+    indented: false,
+    open(scan, parent, line, _width, at) {
+      const last = scan.opened.at(-1);
+      if (last?.kind !== "paragraph" || last.parent !== parent)
+        return;
+      return setextUnderline(line.text.slice(at)) ? leafAt(parent, line) : undefined;
+    }
+  },
+  {
+    triggers: "-*_",
+    interrupts: true,
+    indented: false,
+    open: (_scan, parent, line, _width, at) => thematicBreak(line.text.slice(at)) ? leafAt(parent, line) : undefined
+  },
+  {
+    triggers: "-+*0123456789",
+    interrupts: true,
+    indented: false,
+    open(scan, parent, line) {
+      const last = scan.opened.at(-1);
+      if (last?.kind === "list" || scan.skipList) {
+        scan.skipList = false;
+        return;
+      }
+      const marker = listMarker(line);
+      if (marker === undefined || frontMatterHolds(scan, parent))
+        return;
+      if (marker.empty || marker.number !== undefined && marker.number !== "1") {
+        if (last?.kind === "paragraph" && last.parent === parent)
+          return;
+        if (interruptsOpenBlock(scan, parent))
+          return;
+      }
+      scan.emptyItemWithBlankLines = false;
+      return { block: { kind: "list", marker: marker.char, ...under(parent) }, children: true };
+    }
+  },
+  {
+    triggers: "-+*0123456789",
+    interrupts: true,
+    indented: false,
+    open(scan, parent, line) {
+      if (parent.kind !== "list")
+        return;
+      const previous = parent.last?.kind === "item" ? parent.last.offset : 0;
+      const marker = listMarker(line);
+      if (marker === undefined || marker.indent - previous > 3)
+        return;
+      scan.emptyItemWithBlankLines = false;
+      const after = line.spacesAt(marker.end);
+      const spacing = marker.empty || after > 4 ? 1 : after;
+      const offset = line.columnAt(marker.end) - line.column + spacing;
+      const item = { kind: "item", offset, ...under(parent) };
+      if (marker.empty)
+        return { block: item, children: false };
+      line.advanceTo(marker.end);
+      line.skip(spacing);
+      return { block: item, children: true };
+    }
+  },
+  {
+    interrupts: false,
+    indented: true,
+    open(scan, parent, line, width) {
+      if (width < 4)
+        return;
+      line.skip(4);
+      const previous = scan.lines[scan.index - 1];
+      const block = {
+        kind: "code",
+        lastLine: scan.index,
+        blankBefore: previous === undefined || /^[ \t]*$/.test(previous),
+        ...under(parent)
+      };
+      return { block, children: false };
+    }
+  },
+  {
+    triggers: "#",
+    interrupts: true,
+    indented: false,
+    open: (_scan, parent, line, _width, at) => /^#{1,6}(?:[ \t]|$)/.test(line.text.slice(at)) ? leafAt(parent, line) : undefined
+  },
+  {
+    triggers: "`~",
+    interrupts: true,
+    indented: false,
+    open(_scan, parent, line, _width, at) {
+      const char = line.text.charAt(at);
+      const length = runOf(line.text, at, char);
+      if (length < 3)
+        return;
+      if (char === "`" && line.text.slice(at + length).includes("`"))
+        return;
+      line.advanceTo(line.text.length);
+      return { block: { kind: "fence", char, length, ...under(parent) }, children: false };
+    }
+  },
+  {
+    triggers: ">",
+    interrupts: true,
+    indented: false,
+    open: (scan, parent, line) => !frontMatterHolds(scan, parent) && quoteMarker(line) ? { block: { kind: "quote", ...under(parent) }, children: true } : undefined
+  },
+  {
+    triggers: ":",
+    interrupts: true,
+    indented: false,
+    open: (_scan, parent, line, _width, at) => refusedDirective(line.text.slice(at)) ? leafAt(parent, line) : undefined
+  },
+  {
+    triggers: ":",
+    interrupts: true,
+    indented: false,
+    open(scan, parent, line, width, at) {
+      const opener = typedOpener(line.text.slice(at));
+      if (opener === undefined)
+        return;
+      let draft;
+      if (opener.name === "ask") {
+        draft = { id: opener.id, lines: [] };
+        scan.drafts.push(draft);
+      }
+      line.advanceTo(line.text.length);
+      const block = {
+        kind: "typed",
+        fence: opener.colons,
+        indent: width,
+        draft,
+        ...under(parent)
+      };
+      return { block, children: true };
+    }
+  },
+  {
+    triggers: "[",
+    interrupts: true,
+    indented: false,
+    open(scan, parent, line, _width, at) {
+      const definition = /^\[\^([^\]]*)\]:/.exec(line.text.slice(at));
+      if (definition === null || /^\s*$/.test(definition[1] ?? ""))
+        return;
+      if (frontMatterHolds(scan, parent))
+        return;
+      const label = at + definition[0].length;
+      const content = line.text.slice(label).search(/[^ \t]/);
+      line.advanceTo(content < 0 ? label : label + content);
+      return { block: { kind: "footnote", ...under(parent) }, children: true };
+    }
+  },
+  {
+    interrupts: false,
+    indented: false,
+    open: (scan, parent, line) => {
+      const block = {
+        kind: "paragraph",
+        rows: [line.rest()],
+        lastLine: scan.index,
+        ...under(parent)
+      };
+      line.advanceTo(line.text.length);
+      return { block, children: false };
+    }
+  }
+];
+function interruptsOpenBlock(scan, parent) {
+  let previous = parent.last;
+  const opensContainers = previous === undefined;
+  let node = parent;
+  while (previous === undefined && node !== undefined && node.kind !== "document") {
+    previous = node.previous;
+    node = node.parent;
+  }
+  if (previous?.kind === "paragraph") {
+    return opensContainers && !previous.rows.slice(1).some((row) => TABLE_DELIMITER_ROW.test(row)) && scan.index - previous.lastLine <= 1;
+  }
+  if (previous?.kind !== "code")
+    return false;
+  if (previous.previous?.kind === "list")
+    return false;
+  if (previous.previous?.kind === "quote" && !previous.blankBefore)
+    return false;
+  return scan.lines.slice(previous.lastLine + 1, scan.index).every((row) => /^[ \t>]*$/.test(row));
+}
+var TABLE_DELIMITER_ROW = /^(?=.*\|)[ \t]*\|?[ \t]*:?-+:?[ \t]*(?:\|[ \t]*:?-+:?[ \t]*)*\|?[ \t]*$/;
+function continueBlock(scan, block, line) {
+  switch (block.kind) {
+    case "quote":
+      return quoteMarker(line) ? "children" : "close";
+    case "list":
+      return continueList(scan, block, line);
+    case "item":
+      return continueItem(scan, block, line);
+    case "footnote": {
+      if (line.blank())
+        return "children";
+      const { width } = line.indent();
+      if (width < 4)
+        return "close";
+      line.skip(4);
+      return "children";
+    }
+    case "typed": {
+      const { width, at } = line.indent();
+      if (width < 4 && at < line.text.length && fenceColons(line.text.slice(at)) >= block.fence) {
+        line.advanceTo(line.text.length);
+        return "close";
+      }
+      if (at < line.text.length)
+        line.skip(Math.min(width, block.indent));
+      block.draft?.lines.push(line.rest());
+      return "children";
+    }
+    case "fence": {
+      const { width, at } = line.indent();
+      if (width < 4) {
+        const length = runOf(line.text, at, block.char);
+        if (length >= block.length && /^[ \t]*$/.test(line.text.slice(at + length))) {
+          line.advanceTo(line.text.length);
+          return "close";
+        }
+      }
+      line.advanceTo(line.text.length);
+      return "continue";
+    }
+    case "code": {
+      if (line.blank())
+        return "continue";
+      if (line.indent().width < 4)
+        return "close";
+      block.lastLine = scan.index;
+      line.advanceTo(line.text.length);
+      return "continue";
+    }
+    default:
+      return block.kind === "document" ? "children" : "close";
+  }
+}
+function continueList(scan, list, line) {
+  const last = list.last;
+  const lastIsEmpty = last === undefined || last.children === 0;
+  if (line.blank()) {
+    if (lastIsEmpty)
+      scan.emptyItemWithBlankLines = true;
+    return "children";
+  }
+  const offset = last?.kind === "item" ? last.offset : 0;
+  const { width, at } = line.indent();
+  if (width < offset || lastIsEmpty) {
+    if (width < 4) {
+      const marker = listMarker(line);
+      if (marker !== undefined && marker.indent - offset < 4) {
+        if (marker.char !== list.marker)
+          return "close";
+        const fromMarker = line.text.slice(at);
+        const heading = scan.opened.at(-1)?.kind === "paragraph" && setextUnderline(fromMarker);
+        if (thematicBreak(fromMarker) && !heading)
+          return "close";
+        return "children";
+      }
+    }
+    if (!lastIsEmpty)
+      return "close";
+  }
+  if (lastIsEmpty && width < offset)
+    return "close";
+  if (scan.emptyItemWithBlankLines)
+    return "close";
+  return "children";
+}
+function continueItem(scan, item, line) {
+  const { width } = line.indent();
+  if (line.blank()) {
+    line.skip(Math.min(width, item.offset));
+    return "children";
+  }
+  const isEmpty = item.children === 0 && scan.emptyItemWithBlankLines;
+  if ((isEmpty || width < item.offset) && width < 4) {
+    if (listMarker(line) !== undefined) {
+      scan.skipList = true;
+      return "close";
+    }
+    if (!isEmpty)
+      return "close";
+  }
+  line.skip(Math.min(width, item.offset));
+  return "children";
+}
+function listMarker(line) {
+  const { width, at } = line.indent();
+  if (width > 3)
+    return;
+  const { text } = line;
+  const first = text.charAt(at);
+  let end = at;
+  let number;
+  if (first === "-" || first === "*" || first === "+") {
+    end = at + 1;
+  } else {
+    while (end < text.length && end - at <= 9 && /[0-9]/.test(text.charAt(end)))
+      end++;
+    const delimiter = text.charAt(end);
+    if (end === at || end - at > 9 || delimiter !== "." && delimiter !== ")")
+      return;
+    number = text.slice(at, end);
+    end++;
+  }
+  const after = text.charAt(end);
+  if (end < text.length && after !== " " && after !== "\t")
+    return;
+  return {
+    indent: width,
+    end,
+    char: text.charAt(end - 1),
+    number,
+    empty: /^[ \t]*$/.test(text.slice(end))
+  };
+}
+function quoteMarker(line) {
+  const { width, at } = line.indent();
+  if (width > 3 || line.text.charAt(at) !== ">")
+    return false;
+  line.advanceTo(at + 1);
+  const next = line.text.charAt(at + 1);
+  if (next === " " || next === "\t")
+    line.skip(1);
+  return true;
+}
+function thematicBreak(text) {
+  const marks = text.replace(/[ \t]/g, "");
+  return marks.length >= 3 && /^(?:\*+|-+|_+)$/.test(marks);
+}
+function setextUnderline(text) {
+  return /^(?:=+|-+)[ \t]*$/.test(text);
+}
+function runOf(text, index, char) {
+  let end = index;
+  while (text.charAt(end) === char)
+    end++;
+  return end - index;
+}
+function fenceColons(text) {
+  const trimmed = text.replace(/^[ \t]+|[ \t]+$/g, "");
+  return /^:+$/.test(trimmed) ? trimmed.length : 0;
+}
+function nameChar(char) {
+  return /^[A-Za-z0-9_-]$/.test(char);
+}
+function typedOpener(text) {
+  const colons = runOf(text, 0, ":");
+  if (colons < 3)
+    return;
+  const rest = text.slice(colons);
+  let nameEnd = 0;
+  while (nameEnd < rest.length && nameChar(rest.charAt(nameEnd)))
+    nameEnd++;
+  if (nameEnd === 0 || rest.charAt(nameEnd) !== "{" || !rest.endsWith("}"))
+    return;
+  const attributes = directiveAttributes(rest.slice(nameEnd + 1, -1));
+  if (attributes === undefined)
+    return;
+  return { name: rest.slice(0, nameEnd), id: attributes.id, colons };
+}
+function refusedDirective(text) {
+  if (text.startsWith(":::"))
+    return text !== ":::" && typedOpener(text) === undefined;
+  if (text.startsWith("::"))
+    return text.length > 2 && nameChar(text.charAt(2));
+  return text.length > 1 && nameChar(text.charAt(1)) && text.includes("{");
+}
+function attributeSpace(char) {
+  return char === " " || char >= "\t" && char <= "\r";
+}
+var BLOCK_ID_ATTRIBUTE = "blockId";
+function directiveAttributes(value) {
+  const named = new Set;
+  let id;
+  let offset = 0;
+  const name = () => {
+    const start = offset;
+    while (offset < value.length && nameChar(value.charAt(offset)))
+      offset++;
+    return value.slice(start, offset);
+  };
+  while (offset < value.length) {
+    while (offset < value.length && attributeSpace(value.charAt(offset)))
+      offset++;
+    if (offset === value.length)
+      break;
+    const sigil = value.charAt(offset);
+    if (sigil === "#") {
+      offset++;
+      const read = name();
+      if (read === "" || named.has(BLOCK_ID_ATTRIBUTE))
+        return;
+      named.add(BLOCK_ID_ATTRIBUTE);
+      id = read;
+    } else if (sigil === ".") {
+      offset++;
+      if (name() === "")
+        return;
+      named.add("class");
+    } else {
+      const key = name();
+      if (key === "" || named.has(key))
+        return;
+      named.add(key);
+      if (offset === value.length || value.charAt(offset) === " ")
+        continue;
+      if (value.charAt(offset) !== "=" || value.charAt(offset + 1) !== '"')
+        return;
+      offset += 2;
+      const start = offset;
+      let escaped = false;
+      while (offset < value.length && (value.charAt(offset) !== '"' || escaped)) {
+        escaped = value.charAt(offset) === "\\" && !escaped;
+        offset++;
+      }
+      if (offset === value.length)
+        return;
+      const quoted = value.slice(start, offset);
+      if (!goQuoted(quoted))
+        return;
+      if (key === BLOCK_ID_ATTRIBUTE)
+        id = /[\\&]/.test(quoted) ? undefined : quoted;
+      offset++;
+    }
+    if (offset < value.length && !attributeSpace(value.charAt(offset)))
+      return;
+  }
+  return { id };
+}
+function goQuoted(body) {
+  return /^(?:[^\\\n"]|\\(?:[abfnrtv\\"]|x[0-9A-Fa-f]{2}|[0-3][0-7]{2}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8}))*$/.test(body);
+}
+
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({
   status: "aborted"
@@ -15892,8 +16553,8 @@ class DispatchClient {
   async listProjectArtifacts(project, unlinked = false) {
     return this.#json("GET", ["api", "v1", "projects", project, "artifacts"], undefined, unlinked ? { unlinked: "true" } : undefined);
   }
-  async projectArtifact(project, input) {
-    return this.#upload(["api", "v1", "projects", project, "artifacts"], input);
+  async projectArtifact(project, input, key) {
+    return this.#upload(["api", "v1", "projects", project, "artifacts"], input, key);
   }
   async getProjectArtifact(project, slug) {
     return this.#json("GET", ["api", "v1", "projects", project, "artifacts", slug]);
@@ -16145,8 +16806,8 @@ class DispatchClient {
   async messageBlocks(id, session) {
     return this.#json("GET", ["api", "v1", "messages", id, "blocks"], undefined, session === undefined ? undefined : { session });
   }
-  async docEdit(id, input) {
-    return this.#json("POST", ["api", "v1", "artifacts", id, "edits"], input);
+  async docEdit(id, input, key) {
+    return this.#json("POST", ["api", "v1", "artifacts", id, "edits"], input, undefined, undefined, key);
   }
   async nameArtifactVersion(id, input) {
     return this.#json("POST", ["api", "v1", "artifacts", id, "versions"], input);
@@ -16202,17 +16863,17 @@ class DispatchClient {
       throw error;
     }
   }
-  async#json(method, path, body, query, signal) {
-    return (await this.#jsonAnswer(method, path, body, query, signal)).payload;
+  async#json(method, path, body, query, signal, key) {
+    return (await this.#jsonAnswer(method, path, body, query, signal, key)).payload;
   }
-  async#jsonAnswer(method, path, body, query, signal) {
+  async#jsonAnswer(method, path, body, query, signal, key) {
     const url = this.#url(path, query);
-    const response = await this.#send(method, url, body === undefined ? undefined : { content: JSON.stringify(body), type: "application/json" }, undefined, signal);
+    const response = await this.#send(method, url, body === undefined ? undefined : { content: JSON.stringify(body), type: "application/json" }, undefined, signal, key);
     return { status: response.status, payload: await this.#response(method, url, response) };
   }
-  async#upload(path, input) {
+  async#upload(path, input, key) {
     if ("content" in input)
-      return this.#json("POST", path, input);
+      return this.#json("POST", path, input, undefined, undefined, key);
     const form = new FormData;
     form.set("name", input.name);
     if (input.summary !== undefined)
@@ -16220,17 +16881,17 @@ class DispatchClient {
     if (input.actor !== undefined)
       form.set("actor", JSON.stringify(input.actor));
     form.set("file", input.file, input.name);
-    return this.#form("POST", path, form);
+    return this.#form("POST", path, form, key);
   }
-  async#form(method, path, form) {
+  async#form(method, path, form, key) {
     const url = this.#url(path);
     const encoded = new Response(form);
     const type = encoded.headers.get("Content-Type") ?? "multipart/form-data";
     const content = new Uint8Array(await encoded.arrayBuffer());
-    const response = await this.#send(method, url, { content, type });
+    const response = await this.#send(method, url, { content, type }, undefined, undefined, key);
     return this.#response(method, url, response);
   }
-  async#send(method, url, body, accept = "application/json", signal) {
+  async#send(method, url, body, accept = "application/json", signal, callerKey) {
     const headers = {
       Accept: accept,
       Authorization: `Bearer ${this.token}`
@@ -16245,7 +16906,7 @@ class DispatchClient {
         ...body === undefined ? {} : { body: body.content }
       });
     }
-    const key = crypto.randomUUID();
+    const key = callerKey ?? crypto.randomUUID();
     headers[IDEMPOTENCY_KEY_HEADER] = key;
     const { pausesMs, withinMs, silenceMs, pause = pauseFor } = this.writeRetry;
     const request = `${method} ${url}`;
@@ -17289,7 +17950,7 @@ var RELATION_PHRASES = {
   replied_to_your_message: "replied to your message"
 };
 function isNoAnswersRoute(error) {
-  return error instanceof DispatchServiceError && error.status === 404;
+  return isNoRoute(error);
 }
 function renderSessionAnswerItem(item) {
   const relation = `${RELATION_PHRASES[item.relation]}${item.replaced === true ? " (replaces an earlier answer)" : ""}`;
@@ -17328,7 +17989,7 @@ function renderSessionAnswersList(items, options) {
 
 `);
 }
-var STATE_KEY = Symbol.for("legion.pi-envoy.session-answers.v2");
+var STATE_KEY = Symbol.for("legion.pi-envoy.session-answers.v3");
 var processGlobal = globalThis;
 var state = processGlobal[STATE_KEY] ?? {
   sessions: new Map,
@@ -18142,6 +18803,9 @@ async function resolveOwnerArguments(tool, input, cwd, env, exec, dashboardUrls,
   const issue = `${repo}#${legionIssue}`;
   return { args: { ...args, issue }, ref, owner: { kind: "issue", issue } };
 }
+
+class DocumentNotFoundError extends Error {
+}
 function artifactByReference(artifacts, artifactReference, owner, canonical) {
   const bySlug = artifacts.find((candidate) => candidate.slug === artifactReference);
   if (canonical && bySlug !== undefined)
@@ -18162,7 +18826,7 @@ function artifactByReference(artifacts, artifactReference, owner, canonical) {
   }
   const [artifact] = byName;
   if (artifact === undefined) {
-    throw new Error(documentReferenceProblem(artifactReference, artifacts, owner));
+    throw new DocumentNotFoundError(documentReferenceProblem(artifactReference, artifacts, owner));
   }
   return artifact;
 }
@@ -18193,10 +18857,25 @@ async function resolveArtifact(client, owner, artifactReference, { canonical = f
     artifact = artifactByReference(issue.artifacts, artifactReference, "issue", canonical);
   }
   if (!artifact) {
-    throw new Error(documentReferenceProblem(artifactReference ?? "spec", issue.artifacts, "issue"));
+    throw new DocumentNotFoundError(documentReferenceProblem(artifactReference ?? "spec", issue.artifacts, "issue"));
   }
   return { owner, issue, artifact };
 }
+async function documentTargets(client, resolution) {
+  const refDocument = resolution.ref?.kind === "artifact" ? resolution.ref.id : resolution.ref?.artifact;
+  const owner = resolution.owner?.kind === "issue" ? { kind: "issue", issue: await resolveExistingIssue(client, resolution.owner.issue) } : resolution.owner;
+  return {
+    owner,
+    documentOwner: () => {
+      if (owner === null)
+        throw new Error("issue or project is required");
+      return owner;
+    },
+    resolveDocument: (documentOwner, reference) => resolveArtifact(client, documentOwner, reference, {
+      canonical: reference !== undefined && reference === refDocument
+    })
+  };
+}
 var documentHintLimit = 8;
 function documentReferenceProblem(reference, documents, owner, use) {
   const hints = documents.slice(0, documentHintLimit).map((document) => use === "id" ? `${document.id} (${document.slug}, ${document.name})` : `${document.slug} (${document.name})`);
@@ -18777,13 +19456,11 @@ ${text}`,
 }
 var BLOCK_OPENING_CHARS = 60;
 async function listDocumentBlocks(client, artifact) {
-  const before = await client.docRead(artifact.id);
-  const blocks = await client.artifactBlocks(artifact.id);
-  const after = await client.docRead(artifact.id);
-  if (before.token !== after.token || before.markdown !== after.markdown) {
+  const live = await liveBlocks(client, artifact);
+  if (live === undefined) {
     throw new Error(`${artifact.name} changed while dispatch doc-read --blocks read it, so the opening words could name the wrong text; nothing is listed. Run it again.`);
   }
-  const bytes = new TextEncoder().encode(before.markdown);
+  const { bytes, blocks } = live;
   const decoder = new TextDecoder;
   const lines = [
     `Blocks of ${artifact.name}, in document order, each indented under the block holding it: id, type, (token; anchored comments and asks), opening words. A table lists its rows by the index delete_row takes and its cells by the row and the column delete_column takes.`
@@ -18814,7 +19491,15 @@ async function listDocumentBlocks(client, artifact) {
     holders.push(block);
   }
   return { text: lines.join(`
-`), token: before.token };
+`), token: live.token };
+}
+async function liveBlocks(client, artifact) {
+  const before = await client.docRead(artifact.id);
+  const blocks = await client.artifactBlocks(artifact.id);
+  const after = await client.docRead(artifact.id);
+  if (before.token !== after.token || before.markdown !== after.markdown)
+    return;
+  return { bytes: new TextEncoder().encode(before.markdown), token: before.token, blocks };
 }
 async function refuseOpenDecisionBlocks(client, tool, resolved) {
   const artifact = resolved.artifact;
@@ -19024,14 +19709,7 @@ async function executeDispatchTool(input) {
   const args = checked.args;
   const actor = toolActor(await resolveOrigin(env, exec, input.cwd), input);
   const client = dispatchClient();
-  const refDocument = ownerArguments.ref?.kind === "artifact" ? ownerArguments.ref.id : ownerArguments.ref?.artifact;
-  const resolveDocument = (documentOwner, reference) => resolveArtifact(client, documentOwner, reference, {
-    canonical: reference !== undefined && reference === refDocument
-  });
-  const owner = ownerArguments.owner?.kind === "issue" ? {
-    kind: "issue",
-    issue: await resolveExistingIssue(client, ownerArguments.owner.issue)
-  } : ownerArguments.owner;
+  const { owner, documentOwner, resolveDocument } = await documentTargets(client, ownerArguments);
   const issueArgument = optionalString(input.args, "issue");
   const refText = optionalString(ownerArguments.args, "ref");
   if (input.tool !== "dispatch_ask" && owner?.kind === "issue" && issueArgument !== undefined && refText !== undefined && ownerArguments.ref?.owner.kind === "issue" && owner.issue !== ownerArguments.ref.owner.issue) {
@@ -19044,11 +19722,6 @@ async function executeDispatchTool(input) {
       throw new Error("issue is required");
     return owner.issue;
   };
-  const documentOwner = () => {
-    if (owner === null)
-      throw new Error("issue or project is required");
-    return owner;
-  };
   const postWithPictures = (text, limit, owner, upload) => textWithPictures(input.tool, text, pictures, limit, owner, (picture) => upload(picture).catch((error) => {
     if (!(error instanceof DispatchWriteLandedError))
       throw error;
@@ -21322,12 +21995,16 @@ async function runDispatchCli(argv, rawEnv, io) {
             uploadBytes = bytes;
         }
         const spent = consumeMarker(gate.stores, argv, parsed.args, files, Date.now());
+        const asksCarried = spent.ok ? 0 : newAsks(parsed.tool, uploadBytes === undefined ? parsed.args : { ...parsed.args, content: new TextDecoder().decode(uploadBytes) }).length;
         if (!spent.ok && gate.mode === "block") {
-          return refuse(spent.changed === undefined ? `${notCalled} AskGate is on for this session, and ${spent.why}. ${LITERAL_FORM} Send the write again in that form, as a bash call of its own.` : `${notCalled} AskGate is on for this session, and ${spent.why}. ${SAME_MESSAGE} Send the call again in a later message.`, REFUSED, parsed.tool, { mode: "block", why: spent.why });
+          return refuse(spent.changed === undefined ? `${notCalled} AskGate is on for this session, and ${spent.why}. ${LITERAL_FORM} Send the write again in that form, as a bash call of its own.` : `${notCalled} AskGate is on for this session, and ${spent.why}. ${SAME_MESSAGE} Send the call again in a later message.`, REFUSED, parsed.tool, { mode: "block", why: spent.why, asksCarried });
         }
         if (!spent.ok) {
           try {
-            appendResult(dir, { tool: parsed.tool, askgate: { mode: "warn", why: spent.why } });
+            appendResult(dir, {
+              tool: parsed.tool,
+              askgate: { mode: "warn", why: spent.why, asksCarried }
+            });
           } catch (error) {
             return refuse(`${notCalled} AskGate is on for this session in warn mode, and ${spent.why}. A write that posts unreviewed is first recorded in this session's ledger, and the ledger could not be written: ${messageFor(error)}.`, REFUSED, parsed.tool);
           }

package/dist/src/server.js

@@ -15643,7 +15643,7 @@ function sourceSession(sessionID) {
 // src/server.ts
 import { tool } from "@opencode-ai/plugin/tool";
 // package.json
-var version2 = "12.2.0";
+var version2 = "12.3.0";
 
 // src/log.ts
 import { appendFile, mkdir } from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/opencode-legion-envoy",
-  "version": "12.2.0",
+  "version": "12.3.0",
   "license": "Apache-2.0",
   "type": "module",
   "main": "dist/src/server.js",