@sjawhar/pi-legion-envoy 7.5.0 → 7.5.1

package/dist/legion.js

@@ -17475,7 +17475,7 @@ function endInjectedUserTurns(sessionID) {
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "7.5.0",
+  version: "7.5.1",
   license: "Apache-2.0",
   type: "module",
   omp: {
@@ -17843,6 +17843,7 @@ var LegionThreadOutcome = exports_external.union([
 ]);
 var LegionThreadsResolveResponse = exports_external.strictObject({
   threads: exports_external.array(LegionThreadOutcome),
+  withheld: exports_external.number().int().nonnegative(),
   refused: exports_external.strictObject({ url: nonEmptyString, error: nonEmptyString }).optional()
 });
 var LegionEmptyResponse = exports_external.strictObject({});
@@ -18867,9 +18868,10 @@ var LEGION_HANDOFF_COMPLETE = {
   },
   refusal: (attempt) => `refused \`${attempt}\`: a phase is completed with the \`legion\` tool's ` + "`handoff_complete`, never a shell command: the tool call is what records the phase " + "complete. A root architect or a `task` subagent has no handoff actions: it leaves the " + "completion to the worker. Text that only names the command (a commit message, a PR body) " + "reads as the command: pass it in a file."
 };
+var TREE_PANE_RULES = [JJ_LOG_REWRITE, LEGION_HANDOFF_COMPLETE];
 var PANE_RULES = {
-  "phase-worker": [JJ_LOG_REWRITE, LEGION_HANDOFF_COMPLETE],
-  "root-architect": [LEGION_HANDOFF_COMPLETE]
+  "phase-worker": TREE_PANE_RULES,
+  "root-architect": TREE_PANE_RULES
 };
 function refusedCommand(command, commands, rule) {
   if (commands === undefined) {
@@ -18916,7 +18918,11 @@ function paneRuleRefusal(toolCall, rules) {
 }
 var LEGION_LOADED_MARKER = Symbol.for("legion.pi-envoy.legion-loaded");
 var CODE_MUTATION_TOOLS = ["edit", "write", "apply_patch"];
-var MERGER_BLOCKED_TOOLS = [...CODE_MUTATION_TOOLS, "task"];
+var CODE_TOOL_REFUSAL = {
+  architect: "the architect delegates all code work to phase workers",
+  reviewer: "the reviewer edits nothing except the final .legion/ cleanup commit via bash",
+  merger: "the merger only verifies and reports"
+};
 var TOOL_DEVICE_URL = /^xd:\/\//iu;
 function isToolDeviceInvocation(toolCall) {
   return toolCall.toolName === "write" && typeof toolCall.input.path === "string" && TOOL_DEVICE_URL.test(toolCall.input.path);
@@ -18999,24 +19005,10 @@ function legionExtension(pi) {
       return;
     const sessionID = context.sessionManager.getSessionId();
     const active = claimSession.capability(sessionID);
-    const isToolDevice = isToolDeviceInvocation(toolCall);
-    if (active?.role === "architect" && !isToolDevice && (CODE_MUTATION_TOOLS.includes(toolCall.toolName) || toolCall.toolName === "bash" && !isSingleLegionCommand(toolCall.input.command))) {
-      return { block: true, reason: "the architect delegates all code work to phase workers" };
-    }
-    if (active?.role === "architect" && toolCall.toolName === "task") {
-      return {
-        block: true,
-        reason: "the architect delegates only through child issues and the daemon's phase workers; Legion runs one agent per process"
-      };
-    }
-    if (active?.role === "reviewer" && !isToolDevice && CODE_MUTATION_TOOLS.includes(toolCall.toolName)) {
-      return {
-        block: true,
-        reason: "the reviewer edits nothing except the final .legion/ cleanup commit via bash"
-      };
-    }
-    if (active?.role === "merger" && !isToolDevice && MERGER_BLOCKED_TOOLS.includes(toolCall.toolName)) {
-      return { block: true, reason: "the merger only verifies and reports" };
+    const codeToolRefusal = active === undefined ? undefined : CODE_TOOL_REFUSAL[active.role];
+    const mutatesCode = CODE_MUTATION_TOOLS.includes(toolCall.toolName) || active?.role === "architect" && toolCall.toolName === "bash" && !isSingleLegionCommand(toolCall.input.command);
+    if (codeToolRefusal !== undefined && mutatesCode && !isToolDeviceInvocation(toolCall)) {
+      return { block: true, reason: codeToolRefusal };
     }
     if (!needsGrant(toolCall))
       return;
@@ -19108,5 +19100,6 @@ function legionExtension(pi) {
 }
 export {
   setLegionBootstrapExitForTests,
-  legionExtension as default
+  legionExtension as default,
+  CODE_TOOL_REFUSAL
 };

package/dist/skills/legion-architect/SKILL.md

@@ -285,6 +285,13 @@ is open. That is the one review-thread step a human takes: the review App cannot
 on a pull request the implementer opened, and the implementer's and merger's runs of the command
 close every accepted one.
 
+If a reviewer reports that `legion threads resolve` exited 1 counting threads that hold the
+implement App's pending draft (the daemon counts them and never names them), tell the worker
+holding the issue's phase (`envoy_publish` to its role topic) to move the issue back to
+`implementing` with `request_backward_move`, naming the count, so the implementer submits or
+discards its pending review; its own run of the command names those threads `left open … an
+unsubmitted draft in a pending review`. Open no ask for it: the implementer clears it.
+
 ## 7. Close
 
 After the merge result and the implementer's production report are recorded, post the sign-off and

package/dist/skills/legion-worker/references/review-threads.md

@@ -20,7 +20,16 @@ Every path it cites is in sjawhar/legion.
   the daemon instead (`POST /legion/v1/threads/resolve`), which resolves as the implementer's App
   only the threads a bot outside Legion's role Apps opened whose newest submitted comment is the
   reviewer's `Accepted:`, on the pull request of the reviewer's own issue, and prints the same
-  lines; the reviewer never holds the implementer's token.
+  lines; the reviewer never holds the implementer's token. A thread whose newest comment is a
+  draft in the implement App's pending review (the implementer's or the merger's: GitHub shows it
+  to that App alone, as which the daemon reads) is left open and never named: the command prints
+  only how many there are (`<n> unresolved threads hold the implement App's pending draft and
+  were left open`) and exits 1, as it does on a refusal. Report that count to the architect before
+  you spend your one re-run of the failed workflow; the architect sends the issue back so the
+  implementer submits or discards its pending review. Once the review is submitted, the
+  implementer's reply is the thread's newest comment, which leaves it open: answer the thread
+  again, then run the command again. Once the review is discarded, your `Accepted:` is the newest
+  comment again, and running the command again closes the thread.
   When `LEGION_GRANT_FILE` or `LEGION_GRANT` is set, use `legion threads resolve --pr <number> --repo <owner>/<repo>`.
   When neither is set, add `--gh` to that command, which applies the fallback's rule below through
   your own `gh`; where no `legion` command is installed, use `gh api graphql` with the session's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "7.5.0",
+  "version": "7.5.1",
   "license": "Apache-2.0",
   "type": "module",
   "omp": {