@sjawhar/opencode-legion-envoy 1.15.0 → 1.17.0

package/dist/src/server.js

@@ -13721,7 +13721,9 @@ function snippetText(snippet) {
 // ../contracts/src/dispatch-tools.ts
 function dispatchToolSchema(spec, z, opts) {
   const shape = spec.arguments(z);
-  return spec.validation === undefined ? z.object(shape, opts) : z.refineObject(shape, spec.validation.check, spec.validation.message, opts);
+  const strict = opts?.strict ?? spec.strict;
+  const schemaOptions = strict === undefined ? undefined : { strict };
+  return spec.validation === undefined ? z.object(shape, schemaOptions) : z.refineObject(shape, spec.validation.check, spec.validation.message, schemaOptions);
 }
 var ISSUE_REFERENCE = "An issue is a native KEY or external owner/repo#n reference; an external reference creates its native issue in the repository's dashboard-configured project or, failing that, the default project (DISPATCH_DEFAULT_PROJECT).";
 var OWNER_REFERENCE = "Exactly one of issue and project is required. An issue is a native KEY or external owner/repo#n reference; a project is a project key such as CORE and addresses an unlinked project document named by artifact.";
@@ -13945,6 +13947,12 @@ var dispatchToolSpecs = [
       project: z.string().describe("Optional project key to search within.").optional(),
       limit: z.number({ int: true, min: 1, max: 50 }).describe("Maximum results, 1-50; default 20.").optional()
     })
+  },
+  {
+    name: "dispatch_open_asks",
+    description: "List this session's active unanswered asks across issues and project documents, including age and whose reply is needed. Call before saying you are waiting for human input.",
+    arguments: () => ({}),
+    strict: true
   }
 ];
 // ../contracts/src/envelope.ts
@@ -14682,6 +14690,12 @@ class DispatchClient {
   async ask(issue, input) {
     return this.#json("POST", ["api", "v1", "issues", await this.#resolveIssue(issue), "asks"], input);
   }
+  async openAsks(sessionID, since) {
+    return this.#json("GET", ["api", "v1", "asks", "open"], undefined, {
+      author_session: sessionID,
+      ...since === undefined ? {} : { since }
+    });
+  }
   async resolveAsk(id, input) {
     return this.#json("POST", ["api", "v1", "asks", id, "resolve"], input);
   }
@@ -14934,7 +14948,8 @@ var issueFreeTools = {
   dispatch_issue: true,
   dispatch_edit_ask: true,
   dispatch_resolve_ask: true,
-  dispatch_search: true
+  dispatch_search: true,
+  dispatch_open_asks: true
 };
 function canonicalExternalIssueRef(value) {
   const match = value.trim().match(externalIssueRefPattern);
@@ -15274,6 +15289,45 @@ function askSummary({ ask, replies }) {
   ].join(`
 `);
 }
+function openAskAge(ageSeconds) {
+  const seconds = Math.max(0, Math.floor(ageSeconds));
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60)
+    return `${minutes}m${seconds % 60 === 0 ? "" : ` ${seconds % 60}s`}`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24)
+    return `${hours}h${minutes % 60 === 0 ? "" : ` ${minutes % 60}m`}`;
+  const days = Math.floor(hours / 24);
+  return `${days}d${hours % 24 === 0 ? "" : ` ${hours % 24}h`}`;
+}
+function openAskOwner(ask) {
+  return "issue" in ask.owner ? `${ask.owner.issue.key}: ${ask.owner.issue.title}` : `${ask.owner.document.project} / ${ask.owner.document.name}`;
+}
+function openAskLine(ask, baseUrl) {
+  const priority = ask.priority === null ? "" : `P${ask.priority} \xB7 `;
+  return `- ${openAskAge(ask.age_seconds)} \xB7 ${priority}${openAskOwner(ask)} \xB7 ${ask.question} \xB7 ${new URL(ask.ref, baseUrl).toString()}`;
+}
+function formatOpenAsksSummary(response, baseUrl) {
+  const scope = "active open asks you authored on open issues and project documents";
+  if (response.count === 0) {
+    return ["There are no unanswered asks for this session.", `Scope: ${scope}.`].join(`
+`);
+  }
+  const waitingOnHuman = response.asks.filter((ask) => ask.waiting_on === "human");
+  const waitingOnAgent = response.asks.filter((ask) => ask.waiting_on === "agent");
+  return [
+    `${response.count} unanswered ${response.count === 1 ? "ask" : "asks"} you authored on active issues and project documents.`,
+    "",
+    `Waiting on human (${waitingOnHuman.length}):`,
+    ...waitingOnHuman.map((ask) => openAskLine(ask, baseUrl)),
+    "",
+    `Waiting on agent (${waitingOnAgent.length}):`,
+    ...waitingOnAgent.map((ask) => openAskLine(ask, baseUrl))
+  ].join(`
+`);
+}
 function commentSummary({ comment, replies }) {
   const root = [
     `${comment.id} \xB7 ${comment.author.kind} ${comment.author.id}`,
@@ -15322,6 +15376,15 @@ async function executeDispatchTool(input) {
   if (!input.config.enabled || !configUrl || !configToken) {
     throw new Error("Dispatch is disabled; resolve both DISPATCH_URL and DISPATCH_TOKEN");
   }
+  if (input.tool === "dispatch_open_asks") {
+    const sessionId = input.sessionId?.trim();
+    if (!sessionId)
+      throw new Error("host session id is required for dispatch_open_asks");
+    toolSchema(input.tool).parse(input.args);
+    const client = new DispatchClient(configUrl, configToken, input.fetchImpl, input.signal);
+    const response = await client.openAsks(sessionId);
+    return { text: formatOpenAsksSummary(response, configUrl), details: { ...response } };
+  }
   const env = input.env ?? process.env;
   const exec = input.exec ?? defaultExec;
   const ownerArguments = await resolveOwnerArguments(input.tool, input.args, input.cwd, env, exec);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/opencode-legion-envoy",
-  "version": "1.15.0",
+  "version": "1.17.0",
   "type": "module",
   "main": "dist/src/server.js",
   "exports": {

package/skills/dispatch/SKILL.md

@@ -136,6 +136,8 @@ An ask must be answerable from its own text and its anchor alone. Anchor a quest
 about a comment with `reply_to`; thread a follow-up on your own ask with `reply_to_ask`; cite anything else with a `dispatch://`
 reference (see [References](#references)). Never write "see above", "the message above", or "as attached".
 
+Before saying you are waiting for human input, call `dispatch_open_asks`. It lists this session's active asks across open issues and project documents, including whether the human or agent owes the next reply.
+
 **Anything that needs the human is an ask, or it does not exist.** An approval, a credential,
 a setting only they can change, a review click, a conflict between two of their own rules - if
 your work waits on it, open a `dispatch_ask` with `kind: "action"` the moment you know, the

package/skills/legion-architect/SKILL.md

@@ -244,7 +244,7 @@ corresponding lifecycle procedure.
 | `worker-started` | Payload `{type:"worker-started", issue, role}`. A previously queued role has been promoted and is now running. Treat it exactly as a normal spawn: resume tracking that role's live session. |
 | `pr-ready` | Verify the live PR head, green status, and review state. Continue the review/retro/merger order only for that current head. |
 | `pr-review` | Payload `{type:"pr-review", state, author, body}`. Delivered to whichever role is currently active for the issue, falling back to you when no worker phase is active. Follows the same verdict rule as a reviewer's `phase-complete`: `state: "changes_requested"` sends the implementer back in with the review findings, then tester, then reviewer — never the reviewer again and never retro; `state: "approved"` proceeds toward retro (step 5) once the step 6 integration/merge-gate conditions are met. |
-| `pr-blocked` | Read the failed CI evidence and recovery attempts. Assign a focused implementer or corrective child, then return it through testing and review; do not treat the blocked PR as final. |
+| `pr-blocked` | Payload `{type:"pr-blocked", pr, attempts}`. `attempts` counts heads pushed onto a red verdict that changed something outside `.legion/` — handoff-only pushes (`.legion/` paths only) never count; a push the daemon cannot classify (a listener without `changed_paths`, a list capped at 100, a push listing no commits) does. Published once per exhausted count, not on every later red verdict for that count. Read the failed CI evidence and recovery attempts. Assign a focused implementer or corrective child, then return it through testing and review; do not treat the blocked PR as final. |
 | `pr-merged` | Payload `{type:"pr-merged", pr, mergeCommitSha}`. The merge queue landed the PR. This is your cue for step 7: post the sign-off comment naming that merge commit and set the issue `done`. Nothing else follows a merge. |
 | `pr-closed-unmerged` | Decide from current scope whether to reopen the work, send a fresh implementer, or cancel it with a reason. Delegate the repository action to the responsible phase worker and keep ownership. |
 | `issue-comment` | Interpret the comment in the issue's design context. Answer it, adjust the plan, or relay it via `envoy_publish` to the responsible worker's role token; scope and product decisions remain with you. |

package/skills/legion-worker/SKILL.md

@@ -146,13 +146,20 @@ capability it needs; invoke GitHub through the credential helper:
 legion gh -- <gh args…>
 ```
 
-Three facts about `gh` in a worker pane. The `gh` on your `PATH` is a shim
-(`packages/pi-envoy/src/legion/gh-shim.ts`) that execs `legion gh -- "$@"`, so `gh …` and
-`legion gh -- …` are the same call, and each call redeems a fresh token from your session's
-grant — identity is supplied per call, never stored. Never run `gh auth login` or
-`gh auth setup-git`; there is no login state to create. The shim refuses `pr merge` (and a raw
-`gh api …/merge`): no worker role merges a pull request — the merge queue does, under its own
-authority.
+Four facts about `gh` in a worker pane. The `gh` on your `PATH` is a shim
+(`<state_dir>/worker-bin/gh`, installed by the daemon at startup — `packages/daemon/src/daemon/worker-bin.ts`)
+that execs `legion gh -- "$@"`, so `gh …` and `legion gh -- …` are the same call, and each call
+redeems a fresh token from your session's grant — identity is supplied per call, never stored.
+Never run `gh auth login` or `gh auth setup-git`; there is no login state to create. The shim
+refuses `pr merge` (and a raw `gh api …/merge`): no worker role merges a pull request — the merge
+queue does, under its own authority. The credential reaches `legion` through the file
+`$LEGION_GRANT_FILE` names, written before each of your bash commands by the extension; never
+`cat`, `echo`, copy, or `export` it — `legion credential`, `legion gh`, `jj git push`, and
+`legion handoff complete` read it themselves. The file is the pane's, not the command's: a `task`
+subagent, an `eval` subprocess, or a background job in your pane reads the grant your last bash
+command minted, so its `legion gh` or `jj git push` succeeds only within 60 seconds of that call
+and 403s afterwards — a timing artifact, not a broken credential; run credentialed commands from
+your own bash calls.
 
 ## GitHub PR comment attribution