@sjawhar/opencode-legion-envoy 0.18.1 → 0.19.0

package/dist/src/server.js

@@ -14986,6 +14986,11 @@ var RoleWireSchema = object({
   holder: string2(),
   last_seen: number2().int()
 });
+var RoleHeldWireSchema = object({
+  error: string2(),
+  role: string2(),
+  holder: string2()
+});
 var ErrorWireSchema = object({
   error: string2(),
   expected: array(string2()).optional()
@@ -15118,7 +15123,28 @@ function createEnvoyClient(config) {
     unregisterSession: async (sessionID) => {
       await request(`/v1/sessions/${encodeURIComponent(sessionID)}`, { method: "DELETE" });
     },
-    setRole: async (input) => InterestWireSchema.parse(JSON.parse(await post("/v1/roles/set", { session_id: input.sessionID, role: input.role }))),
+    setRole: async (input) => {
+      const soft = input.soft === true;
+      const previous = soft ? input.previousSessionID ?? "" : "";
+      const body = {
+        session_id: input.sessionID,
+        role: input.role,
+        ...soft ? { soft: true } : {},
+        ...previous === "" ? {} : { previous_session_id: previous }
+      };
+      let raw;
+      try {
+        raw = await post("/v1/roles/set", body);
+      } catch (error) {
+        if (error instanceof EnvoyApiError && error.details.status === 409) {
+          const held = RoleHeldWireSchema.safeParse(JSON.parse(error.details.responseBody));
+          if (held.success)
+            return { claimed: false, holder: held.data.holder };
+        }
+        throw error;
+      }
+      return { claimed: true, interest: InterestWireSchema.parse(JSON.parse(raw)) };
+    },
     getRole: async (role) => RoleWireSchema.parse(JSON.parse(await request(`/v1/roles/${encodeURIComponent(role)}`, { method: "GET" }))),
     listSessions: async (input = {}) => {
       const search = new URLSearchParams;
@@ -15499,7 +15525,13 @@ var server_default = async (input) => {
         args: roleSetSpec.arguments(zodSchemaApi(tool.schema)),
         async execute(args, ctx) {
           ctx.metadata({ title: "Set Envoy role" });
-          return JSON.stringify(await envoy.setRole({ sessionID: ctx.sessionID, role: args.role }));
+          const result = await envoy.setRole({
+            sessionID: ctx.sessionID,
+            role: args.role
+          });
+          if (!result.claimed)
+            throw new Error(`role ${args.role} is held by ${result.holder}`);
+          return JSON.stringify(result.interest);
         }
       }),
       envoy_whoami: tool({

package/package.json

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

package/skills/envoy/SKILL.md

@@ -123,6 +123,21 @@ Publish to a role; do not subscribe as its holder. A successful `envoy_publish`
 its live `holder`; an unheld role returns an error. Use `envoy_role_get(role="reviewer")` to find
 the live holder first when you need one.
 
+A claim belongs to the session, not the process. `omp --resume` re-claims the role recorded in
+the session transcript, including after the listener's stale-interest reaper has removed the old
+row. A `/fork`, `/branch`, `/handoff`, or other transcript-carrying switch checks the
+previous id and moves any held role to the new id while establishing the new session. A `/new`
+or `/resume` switch installs an unrelated transcript and carries nothing. A process that dies and
+is never resumed does not stay a live holder; once liveness expires, role publishes return
+`no holder` until that transcript resumes or another session claims the role.
+
+Automatic reclaim never steals. It is a *soft* claim, which the listener grants only when the role
+is unheld, held by a session that is no longer live, or held by the id this session continues (a
+fork's parent). If a different live session holds it — the parent of a `/fork` whose role moved to
+the child, or a second process on the same transcript — the listener refuses atomically and the
+resumed session logs a warning and holds nothing. Only an explicit `envoy_role_set` is
+last-claim-wins. Re-running `envoy_role_set` for a role this session already holds is harmless.
+
 ## Legion role claims
 
 Legion agents receive through a daemon-minted role token. Claim the assigned role with

package/src/server.ts

@@ -371,9 +371,13 @@ export default async (input: { serverUrl: URL }) => {
         args: roleSetSpec.arguments(zodSchemaApi(tool.schema)) as never,
         async execute(args, ctx) {
           ctx.metadata({ title: "Set Envoy role" });
-          return JSON.stringify(
-            await envoy.setRole({ sessionID: ctx.sessionID, role: args.role as string })
-          );
+          const result = await envoy.setRole({
+            sessionID: ctx.sessionID,
+            role: args.role as string,
+          });
+          // A hard claim always lands; the discriminant exists for soft claims.
+          if (!result.claimed) throw new Error(`role ${args.role} is held by ${result.holder}`);
+          return JSON.stringify(result.interest);
         },
       }),
       envoy_whoami: tool({