@sjawhar/opencode-legion-envoy 6.15.2 → 6.17.0

package/dist/dispatch.js

@@ -17297,22 +17297,31 @@ async function refuseOpenDecisionBlocks(client, tool, resolved) {
   const asks = new Map(documentAsks.map((ask) => [ask.block_id, ask]));
   const lines = version2.markdown.split(`
 `);
+  const stillOpen = (named, state) => {
+    const next = state === "answered" ? "fold the answer into the text" : "write the decision into the text";
+    return `${named}, ${state} but still open in version ${latest}: ${next} with dispatch doc-edit, which writes a version that carries it`;
+  };
   const open = blocks.flatMap((block) => {
     const ask = asks.get(block.id);
+    const openers = lines.filter((line) => line.includes(`ask{#${block.id} `) || line.includes(`ask{#${block.id}}`));
+    const states = openers.map((line) => /\bstate="(\w+)"/.exec(line)?.[1]);
     const named = ask === undefined ? `block ${block.id}` : `${JSON.stringify(ask.question)} (block ${block.id}, ask ${ask.id})`;
-    const states = lines.filter((line) => line.includes(`ask{#${block.id} `) || line.includes(`ask{#${block.id}}`)).map((line) => /\bstate="(\w+)"/.exec(line)?.[1]);
     if (states.length === 0)
       return [`${named}, which version ${latest} does not hold yet`];
     if (!states.includes("open") && states.some((state) => state !== undefined))
       return [];
-    if (ask === undefined)
+    if (ask !== undefined)
+      return ask.state === "open" ? [named] : [stillOpen(named, ask.state)];
+    const attribute = (name) => openers.map((line) => new RegExp(`\\b${name}="([^"]+)"`).exec(line)?.[1]).find((value) => value !== undefined);
+    const sourceId = attribute("copied_from");
+    const document = attribute("copied_from_document");
+    if (sourceId === undefined || document === undefined) {
       return [`${named}, whose ask Dispatch has not opened yet`];
-    if (ask.state === "open")
-      return [named];
-    const next = ask.state === "answered" ? "fold the answer into the text" : "write the decision into the text";
-    return [
-      `${named}, ${ask.state} but still open in version ${latest}: ${next} with dispatch doc-edit, which writes a version that carries it`
-    ];
+    }
+    const source = parseDispatchRef(document);
+    const where = source === null ? document : source.owner.kind === "project" ? documentLabel(source.owner.project, source.id) : `${source.owner.issue} ${source.id}`;
+    const ref = source?.owner.kind === "issue" ? dispatchChildRef(dispatchIssueRef(source.owner.issue), "ask", sourceId) : dispatchChildRef(document, "ask", sourceId);
+    return [`${named}, a copy of ask ${ref}, which is open on ${where}: answer it there`];
   });
   if (open.length === 0)
     return;

package/package.json

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

package/skills/dispatch/references/documents.md

@@ -148,6 +148,20 @@ artifact by the slug the upload printed or by its filename, and a project docume
 slug also arrives on `artifact.created` events. Dispatch suffixes a slug two documents would share, so one document's
 filename can be another's slug (`plan v2` takes `plan-v2`, then a document named `plan-v2` takes `plan-v2-2`): a bare
 `--artifact` that names both is refused with each one's id, while a `dispatch://` reference's document part is always the slug.
+A document you upload holding a copy of another document's `:::ask` block, under the same `#id` and with the same
+question, options, `multiple` and urgency, on the same issue (or the same project for a project document), opens no
+ask: the copy shows the state and answer of the ask it was copied from, names it and its document in `copied_from` and
+`copied_from_document`, and cannot be answered there. Answer the original: its answer or resolution shows on the copy a
+few seconds later. A copy may hold the original's earlier wording, from before someone reworded it. It stays a copy
+while the original is open, and shows an answer or resolution given while the original still asked that wording; an
+answer or resolution given after the rewording decides a question the copy does not ask, so the copy opens its own ask
+instead. A copy whose text you change opens a new ask. Once the original's block leaves its document, its copies share
+one new ask: the first copy to settle opens it and the others name it.
+
+An answered or resolved ask's question is fixed. Editing its block's question, options, `multiple` or urgency in the
+document, or uploading a version that changes them, does not change the ask: a few seconds later the block is written
+back to the question the answer was given on, beside its answer. To ask something new, write a new ask block with its
+own `#id`. An open ask's block is its text: edit it and the ask changes with it.
 
 A picture meant to be seen inline in a message, comment or ask is not uploaded with `dispatch artifact`: pass its local
 path with that command's `--image`, once per picture (PNG, JPEG, GIF or WebP by its bytes, at most 25 MiB each). Each is uploaded to the issue (a

package/skills/legion-controller/SKILL.md

@@ -193,12 +193,17 @@ unsent:
   `controller_wake_interval_seconds` (an hour by default), whatever the slots. An earlier walk
   that found nothing, a day with no event, and [a tree waiting on a root
   claim](#trees-waiting-on-a-root-claim-go-daemon) all get a turn from it. Its payload's
-  `openCapabilities`, when present, names the deployment capabilities (the secrets broker, model
-  fallback, every role's CPU and memory limits) the deployment's own configuration leaves open with
-  no decision recorded. `read_state` lists every row under `capabilities`, each open one
-  with its `detail` and the `configLine` to write into `legion.yaml`
-  (`capabilities.decided.<name>: "<reason>"`); name them in the day's report. A gap is the
-  operator's to close or to decide, never yours, and it never stops the walk.
+  `openCapabilities`, when present, names the open capability rows: the deployment capabilities
+  (the secrets broker, model fallback, every role's CPU and memory limits) the deployment's own
+  configuration leaves open with no decision recorded, and the live capabilities (`subagents`,
+  `web-search`, `mcp`, `repository-extensions`, `dispatch-envoy-tools`, `github`) a running
+  session's own check at its start failed. `read_state` lists every row under `capabilities`, each
+  open one with its `detail`: on a deployment row, with the `configLine` to write into
+  `legion.yaml` (`capabilities.decided.<name>: "<reason>"`); on a live row, naming each failing
+  session (its pod or pane, its role, its issue) and the fact its check found, with no
+  `configLine`, since nothing in `legion.yaml` decides a live row. Name them in the day's report.
+  A gap is the operator's to close or to decide — a live one the operator's or the issue's
+  architect's to fix in the session's environment — never yours, and it never stops the walk.
 
 **Scope first.** The scope the deployment instructions state decides which issues are candidates
 at all, before anything below. When they say you hand Legion no issue yourself, or that Legion
@@ -350,9 +355,12 @@ every pull request by its URL.
   when it made one: what it took, and how many candidates each row of the table skipped, so a
   reader can see why a free slot stays empty.
 - **Open capabilities.** Each row of `capabilities` in `read_state` whose `status` is
-  `open` (the `tick` payload's `openCapabilities`): its name, its `detail`, and its `configLine`,
-  the `legion.yaml` line that records a decision. The operator closes or decides it; you only
-  report it, and a report with none says nothing of them.
+  `open` (the `tick` payload's `openCapabilities`): its name, its `detail`, and, on a deployment
+  row, its `configLine`, the `legion.yaml` line that records a decision. A live row a running
+  session failed has no `configLine`: its `detail` names the session (pod or pane), the role, the
+  issue and the fact, and nothing in `legion.yaml` decides it. The operator closes or decides a
+  deployment row, and the operator or the issue's architect fixes a live row's session
+  environment; you only report either, and a report with none says nothing of them.
 
 A day with nothing finished says so in one sentence. When the lists do not fit, keep the counts
 and the highest-priority issues.
@@ -394,7 +402,7 @@ priority first, then board rank ([Keeping the slots full](#keeping-the-slots-ful
 | New issue created in the Dispatch project, status `triage`: `triage on <KEY>` (payload `{kind: "triage"}`) on the controller topic, for an unrecorded root carrying the `legion` label only ("Issues handed to Legion" above); the start procedure above catches one sent while no controller ran | issue key + triage context (incl. pre-existing children) | Triage: `set_status` to `todo` to admit, or to `backlog`/`icebox` to park |
 | `slot-free on <KEY>` from the Go daemon (payload `{kind: "slot-free"}`) | the root whose slot the daemon released with no waiting root to take it | Verify a free slot in `read_state`, then fill it ([Keeping the slots full](#keeping-the-slots-full-go-daemon)) |
 | `todo on <KEY>` from the Go daemon (payload `{kind: "todo"}`) | an issue not handed to Legion that changed while in `todo` and a slot stood free, sent half a minute later | Verify a free slot, then walk the whole `todo` list ([Keeping the slots full](#keeping-the-slots-full-go-daemon)) |
-| `tick on <PROJECT>` from the Go daemon (payload `{kind: "tick", openCapabilities?: [<name>, …]}`) | the project key; the daemon's periodic wake, whatever the slots; `openCapabilities` names the deployment capabilities with no decision, each with its detail and `capabilities.decided.<name>` line under `capabilities` in `read_state` | Recheck the trees waiting on a claim, then walk if a slot is free — a gap never stops the walk; post the day's report if this is the day's first turn, naming each open capability in it (the operator closes or decides it) |
+| `tick on <PROJECT>` from the Go daemon (payload `{kind: "tick", openCapabilities?: [<name>, …]}`) | the project key; the daemon's periodic wake, whatever the slots; `openCapabilities` names the deployment capabilities with no decision, each with its detail and `capabilities.decided.<name>` line under `capabilities` in `read_state`, and the live capabilities a running session's check failed, each with the detail naming the session (pod or pane), role, issue and fact, and no `configLine` | Recheck the trees waiting on a claim, then walk if a slot is free — a gap never stops the walk; post the day's report if this is the day's first turn, naming each open capability in it (the operator closes or decides a deployment row; the operator or the issue's architect fixes a live row's session; you take no other action) |
 | Architect escalation (controller-actionable only: re-file a child as a root issue, capacity, cross-tree conflicts) | request + context | Judge and act; the owning architect writes an issue-design decision as a decision block and opens `dispatch ask` only for a human to-do |
 | Mention | Slack/GitHub PR @mention text | Answer, or route to the owning issue's architect role |
 | `held on <KEY>` from the Go daemon (payload `{kind: "held", phase, role?, reason?}`) | the held issue, the phase it left, and the role whose claim failed, or `reason: "escalated"` | Verify the hold in `read_state` (the issue's phase is `held`). Without `reason`, a phase worker's launches or prompts ran out and the tree's architect decides retry or escalate: no action. With `reason: "escalated"` (on the record, `issues.<KEY>.holdReason` is `escalated`), the architect sent it to you: handle it as an architect escalation below. Parking the tree is `set_status` of the root to `backlog`; setting the root back to `todo` later re-admits it as a new generation, which starts again from its architect |