@sjawhar/pi-legion-envoy 1.32.0 → 1.33.0

package/dist/envoy.js

@@ -30308,6 +30308,19 @@ var stateRole = strictObject({
   launchFailures: number2().int().nonnegative().optional(),
   locator: stateLocator.optional()
 });
+var stateQueuedWorkerIdentity = {
+  roleToken: nonEmptyString,
+  issue: nonEmptyString,
+  role: nonEmptyString
+};
+var stateQueuedWorker = union([
+  strictObject(stateQueuedWorkerIdentity),
+  strictObject({
+    ...stateQueuedWorkerIdentity,
+    kind: _enum2(["assignment", "catchup"]),
+    queuedAt: nonEmptyString
+  })
+]);
 var LegionDaemonApi = {
   State: {
     response: strictObject({
@@ -30324,7 +30337,8 @@ var LegionDaemonApi = {
       controllerLocator: stateLocator.optional(),
       roles: record(string2(), stateRole),
       controllerPendingNotices: number2().int().nonnegative(),
-      pendingStatusWrites: array(nonEmptyString)
+      pendingStatusWrites: array(nonEmptyString),
+      workerAdmission: strictObject({ queue: array(stateQueuedWorker) })
     })
   },
   ControllerReady: {
@@ -30411,7 +30425,8 @@ var LegionDaemonApi = {
     request: architectCapability.extend({
       issue: nonEmptyString,
       role: legionRole,
-      task: nonEmptyString
+      task: nonEmptyString,
+      requestId: uuid2()
     }),
     response: object({
       status: _enum2(["spawned", "resumed", "queued"]),

package/dist/legion.js

@@ -16112,7 +16112,7 @@ var require_mod4 = __commonJS(function(exports) {
 });
 
 // extensions/legion.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 import fs from "fs";
 import path4 from "path";
 
@@ -30308,6 +30308,19 @@ var stateRole = strictObject({
   launchFailures: number2().int().nonnegative().optional(),
   locator: stateLocator.optional()
 });
+var stateQueuedWorkerIdentity = {
+  roleToken: nonEmptyString,
+  issue: nonEmptyString,
+  role: nonEmptyString
+};
+var stateQueuedWorker = union([
+  strictObject(stateQueuedWorkerIdentity),
+  strictObject({
+    ...stateQueuedWorkerIdentity,
+    kind: _enum2(["assignment", "catchup"]),
+    queuedAt: nonEmptyString
+  })
+]);
 var LegionDaemonApi = {
   State: {
     response: strictObject({
@@ -30324,7 +30337,8 @@ var LegionDaemonApi = {
       controllerLocator: stateLocator.optional(),
       roles: record(string2(), stateRole),
       controllerPendingNotices: number2().int().nonnegative(),
-      pendingStatusWrites: array(nonEmptyString)
+      pendingStatusWrites: array(nonEmptyString),
+      workerAdmission: strictObject({ queue: array(stateQueuedWorker) })
     })
   },
   ControllerReady: {
@@ -30411,7 +30425,8 @@ var LegionDaemonApi = {
     request: architectCapability.extend({
       issue: nonEmptyString,
       role: legionRole,
-      task: nonEmptyString
+      task: nonEmptyString,
+      requestId: uuid2()
     }),
     response: object({
       status: _enum2(["spawned", "resumed", "queued"]),
@@ -30637,6 +30652,14 @@ function parseControlDirective(raw) {
 }
 
 // src/legion/daemon-client.ts
+function defaultSleep(ms) {
+  const { promise, resolve } = Promise.withResolvers();
+  setTimeout(resolve, ms);
+  return promise;
+}
+var SPAWN_WORKER_RETRY_DELAYS_MS = [2000, 5000];
+var SPAWN_WORKER_ATTEMPTS = SPAWN_WORKER_RETRY_DELAYS_MS.length + 1;
+
 class LegionDaemonApiError extends Error {
   method;
   path;
@@ -30650,6 +30673,30 @@ class LegionDaemonApiError extends Error {
     this.responseBody = responseBody;
   }
 }
+
+class LegionDaemonTransportError extends Error {
+  path;
+  requestId;
+  attempts;
+  constructor(path, requestId, attempts, cause) {
+    super(`POST ${path} got no response in ${attempts} attempts (request ${requestId}): ${messageFor(cause)}. The daemon may have received the request; read legion state (workerAdmission.queue and the role's claim) before sending it again.`, { cause });
+    this.path = path;
+    this.requestId = requestId;
+    this.attempts = attempts;
+    this.name = "LegionDaemonTransportError";
+  }
+}
+
+class LegionDaemonResponseReadError extends Error {
+  path;
+  requestId;
+  constructor(path, requestId, cause) {
+    super(`POST ${path} response body could not be read (request ${requestId}): ${messageFor(cause)}. The daemon may have received the request; read legion state (workerAdmission.queue and the role's claim) before sending it again.`, { cause });
+    this.path = path;
+    this.requestId = requestId;
+    this.name = "LegionDaemonResponseReadError";
+  }
+}
 function isInvalidSessionSecret(error) {
   if (!(error instanceof LegionDaemonApiError) || error.status !== 403)
     return false;
@@ -30668,19 +30715,42 @@ function sessionCapability(body) {
   return { sessionId: candidate.sessionId, secret: candidate.secret };
 }
 var WORKER_SESSION_PATH = "/legion/v1/worker-session";
-function createLegionDaemonClient(baseUrl, fetchFn = fetch, recovery) {
+function createLegionDaemonClient(baseUrl, fetchFn = fetch, recovery, sleep = defaultSleep) {
   const endpoint = baseUrl.replace(/\/+$/, "");
-  const postOnce = async (path, body, schema) => {
-    const response = await fetchFn(`${endpoint}${path}`, {
+  const postOnce = async (path, body, schema, fetchImpl = fetchFn, onResponseReadError) => {
+    const response = await fetchImpl(`${endpoint}${path}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body)
     });
-    const responseBody = await response.text();
+    let responseBody;
+    try {
+      responseBody = await response.text();
+    } catch (error) {
+      throw onResponseReadError?.(error) ?? error;
+    }
     if (!response.ok)
       throw new LegionDaemonApiError("POST", path, response.status, responseBody);
     return schema.parse(JSON.parse(responseBody));
   };
+  const transportRetryingFetch = (path, requestId) => {
+    let transportFailures = 0;
+    return async (input, init) => {
+      for (;; ) {
+        try {
+          return await fetchFn(input, init);
+        } catch (error) {
+          transportFailures += 1;
+          const delay = SPAWN_WORKER_RETRY_DELAYS_MS[transportFailures - 1];
+          if (delay === undefined) {
+            throw new LegionDaemonTransportError(path, requestId, transportFailures, error);
+          }
+          console.error(`[legion] POST ${path} attempt ${transportFailures}/${SPAWN_WORKER_ATTEMPTS} got no response (${messageFor(error)}); retrying request ${requestId} in ${delay} ms`);
+          await sleep(delay);
+        }
+      }
+    };
+  };
   const recoveries = new Map;
   const secretAfterRefusal = async (active, sessionId, refusedSecret) => {
     let record = recoveries.get(sessionId);
@@ -30705,16 +30775,16 @@ function createLegionDaemonClient(baseUrl, fetchFn = fetch, recovery) {
     }
     return (await record.inFlight).secret;
   };
-  const post = async (path, body, schema) => {
+  const post = async (path, body, schema, fetchImpl = fetchFn, onResponseReadError) => {
     try {
-      return await postOnce(path, body, schema);
+      return await postOnce(path, body, schema, fetchImpl, onResponseReadError);
     } catch (error) {
       const capability = sessionCapability(body);
       if (path === WORKER_SESSION_PATH || recovery === undefined || capability === undefined || !isInvalidSessionSecret(error)) {
         throw error;
       }
       const secret = await secretAfterRefusal(recovery, capability.sessionId, capability.secret);
-      return await postOnce(path, { ...body, secret }, schema);
+      return await postOnce(path, { ...body, secret }, schema, fetchImpl, onResponseReadError);
     }
   };
   const get = async (path, schema) => {
@@ -30734,7 +30804,7 @@ function createLegionDaemonClient(baseUrl, fetchFn = fetch, recovery) {
     processReady: (input) => noContent("/legion/v1/process/ready", input, LegionDaemonApi.ProcessReady.response),
     workerStarted: (input) => post("/legion/v1/worker/started", input, LegionDaemonApi.WorkerStarted.response),
     workerReady: (input) => noContent("/legion/v1/worker/ready", input, LegionDaemonApi.WorkerReady.response),
-    spawnWorker: (input) => post("/legion/v1/worker/spawn", input, LegionDaemonApi.SpawnWorker.response),
+    spawnWorker: (input) => post("/legion/v1/worker/spawn", input, LegionDaemonApi.SpawnWorker.response, transportRetryingFetch("/legion/v1/worker/spawn", input.requestId), (error) => new LegionDaemonResponseReadError("/legion/v1/worker/spawn", input.requestId, error)),
     releaseWave: (input) => post("/legion/v1/waves/release", input, LegionDaemonApi.WaveRelease.response),
     provisioningCredential: (input) => post("/legion/v1/provisioning-credential", input, LegionDaemonApi.ProvisioningCredential.response),
     escalate: (input) => noContent("/legion/v1/escalate", input, LegionDaemonApi.Escalate.response),
@@ -30813,6 +30883,9 @@ commit_trailers = '"Omp-Session: ${id}"'
   }
 }
 
+// src/legion/tools.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
 // src/tool-result.ts
 function toolSuccess(text, details = {}) {
   return { content: [{ type: "text", text }], details };
@@ -30868,7 +30941,7 @@ function createLegionTool(deps) {
   return {
     name: "legion",
     label: "legion",
-    description: "Perform a Legion lifecycle write through the Legion daemon. " + "register_gate records the root spec document a human must approve: `artifactId` is the " + "document id (a UUID) and `version` the version number, both copied from the `artifact` and " + "`version` fields of dispatch_request_approval's result \u2014 never the slug or file name you " + "passed to that tool. " + `spawn_worker's response "status" means: "spawned" \u2014 a fresh pane just opened and is ` + 'running now; "resumed" \u2014 an existing worker was prompted directly over its live socket ' + "and its turn started, or (if its boot has not confirmed yet) its task was recorded to " + 'deliver once that boot completes; "queued" \u2014 the task was recorded and this role will ' + "start on its own: either the running-worker cap is full, or the live worker acknowledged " + "the task without starting a turn and the daemon is retrying it. Never re-spawn a role " + 'after "resumed" or "queued" \u2014 wait for the worker-started notification instead.',
+    description: "Perform a Legion lifecycle write through the Legion daemon. " + "register_gate records the root spec document a human must approve: `artifactId` is the " + "document id (a UUID) and `version` the version number, both copied from the `artifact` and " + "`version` fields of dispatch_request_approval's result \u2014 never the slug or file name you " + "passed to that tool. " + `spawn_worker's response "status" means: "spawned" \u2014 a fresh pane just opened and is ` + 'running now; "resumed" \u2014 an existing worker was prompted directly over its live socket ' + "and its turn started, or (if its boot has not confirmed yet) its task was recorded to " + 'deliver once that boot completes; "queued" \u2014 the task was recorded and this role will ' + "start on its own: either the running-worker cap is full, or the live worker acknowledged " + "the task without starting a turn and the daemon is retrying it. Never re-spawn a role " + 'after "resumed" or "queued" \u2014 wait for the worker-started notification instead. A call ' + 'that fails with "got no response in 3 attempts" was retried by the plugin with one ' + "request id; the daemon may still have received it \u2014 read legion state " + "(workerAdmission.queue, and the role in roles) before sending it again. A spawn_worker " + "identical to the task already queued for the role changes nothing and is not announced again.",
     defaultInactive: true,
     parameters: legionToolSchema(pi),
     execute: async (_id, parameters, _signal, _onUpdate, context) => {
@@ -30958,13 +31031,15 @@ function createLegionTool(deps) {
             if (typeof role !== "string" || !LEGION_ROLES.includes(role)) {
               throw new Error("spawn_worker requires a valid Legion role");
             }
+            const requestId = randomUUID2();
             return jsonSuccess(await daemon.spawnWorker({
               tree: architect.tree,
               sessionId,
               secret: architect.secret,
               issue: stringInput("issue"),
               role,
-              task: stringInput("task")
+              task: stringInput("task"),
+              requestId
             }));
           }
           default:
@@ -34707,7 +34782,7 @@ function isToolDeviceInvocation(toolCall) {
   return toolCall.toolName === "write" && typeof toolCall.input.path === "string" && toolCall.input.path.startsWith("xd://");
 }
 function legionExtension(pi) {
-  const instance = randomUUID2().slice(0, 8);
+  const instance = randomUUID3().slice(0, 8);
   logger2.debug("extension instance loaded", { extension: import.meta.url, instance });
   globalThis[LEGION_LOADED_MARKER] = import.meta.url;
   const defaults = envoyDefaultsFromEnvironment(process.env);

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

@@ -301,7 +301,7 @@ active phase worker.
 | `design-approved` | Payload `{type:"design-approved"}`. A human approved the root spec document at its current version; the gate is open. Proceed to section 2. |
 | `design-changes-requested` | Payload `{type:"design-changes-requested", version, reason, author?}`. A human asked for changes to the root spec at `version`, for `reason`. Revise the spec, call `dispatch_request_approval` again, and stay parked; the gate is closed. |
 | `phase-complete` | Payload `{type:"phase-complete", issue, role, summary}`. May arrive live or via `catchup-overseer`'s `phaseCompletions`. Read the committed handoff for that phase, then spawn the next phase's owner, or `spawn_worker` on the same role again to resume it with corrections if the handoff shows unresolved gaps. A `reviewer` completion whose GitHub review is `CHANGES_REQUESTED` (the daemon returns the issue's Dispatch status to `in_progress` for this, on the reviewer's completion and again when you spawn the corrective implementer unless the daemon already knows the issue is `in_progress`) means `spawn_worker` the **implementer** again with the review findings — thread URLs and blocking items — as its task, then route back through tester and reviewer in order; never `spawn_worker` the reviewer directly off this wake and never proceed to retro on this verdict. A reviewer completion with an `APPROVED` review proceeds to retro (step 5). A `reviewer` completion after a conflict-forced rebase whose review body names an unchanged fingerprint is a confirmation, not a round: if retro already completed, `spawn_worker` the merger; otherwise resume the step you were on. An `implementer` completion that follows the merge is its production report: read the record on the pull request and the issue, then run step 7 — the issue is already at `retro`, the daemon writes no status for this completion, and you set `done` yourself. A `tester` completion whose handoff carries `implementerProof.verdict: "rejected"`, or a failure naming the production-like proof, goes back to the **implementer** with that finding — never forward to the reviewer, and never by supplying the proof from another role. A worker that reports no surface reaches the changed path gets a child issue in this tree (infrastructure, tooling, or a skill) and a resume once it lands; that report is never a reason to advance the phase. |
-| `worker-queued` | Payload `{type:"worker-queued", issue, role}`. This role's task is queued for promotion — either the deployment's worker cap is full, or the live worker acknowledged the task without starting a turn and the daemon is retrying it (counted; the worker is replaced after three such failures, still with the same task). Do not respawn or retry — wait for `worker-started`. |
+| `worker-queued` | Payload `{type:"worker-queued", issue, role}`. This role's task is queued for promotion — either the deployment's worker cap is full, or the live worker acknowledged the task without starting a turn and the daemon is retrying it (counted; the worker is replaced after three such failures, still with the same task). Do not respawn or retry — wait for `worker-started`. `legion state` shows the queue (`workerAdmission.queue`: role token, issue, role, kind, and the time the task was first queued — never the task text); read it before re-sending. A `spawn_worker` identical to the queued task changes nothing and is not announced again. Different text replaces the queued task silently in the same FIFO slot and retains its original queue time. A `spawn_worker` that fails with "got no response in 3 attempts" was already retried by the plugin under one request id and may still have reached the daemon: read the queue and the role's claim in `legion state` before sending it again. |
 | `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; that `spawn_worker` returns the issue to `in_progress` on its own (the daemon writes it for a corrective implementer whenever the PR's latest recorded review is changes requested, a human's after approval included), so you set nothing by hand; `state: "approved"` proceeds toward retro (step 5) once the step 6 integration/merge-gate conditions are met. `state: "approved"` on a rebased head whose body names an unchanged fingerprint is that confirmation: proceed to retro if it has not run, otherwise to the merger — never to a second retro or test round. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "type": "module",
   "omp": {
     "extensions": [
@@ -12,7 +12,7 @@
     ]
   },
   "legion": {
-    "daemonApiVersion": 3
+    "daemonApiVersion": 4
   },
   "repository": {
     "type": "git",