@sjawhar/pi-legion-envoy 1.60.2 → 1.61.0

package/dist/envoy.js

@@ -30472,6 +30472,10 @@ var handoffMessageSchema = object({
 // ../contracts/src/subject.ts
 var AGENT_TOPIC_PREFIX = "notifications.agent.";
 var ROLE_TOPIC_PREFIX = "notifications.role.";
+var LEGION_NOTICE_TOPIC_PREFIX = "notifications.legion.";
+function legionNoticeSubject(project, issue) {
+  return `${LEGION_NOTICE_TOPIC_PREFIX}${project}.${issue}`;
+}
 var DISPATCH_TOPIC_PREFIX = "notifications.dispatch.";
 var DISPATCH_ISSUE_TOPIC_PREFIX = `${DISPATCH_TOPIC_PREFIX}issue.`;
 var DISPATCH_DOCUMENT_TOPIC_PREFIX = `${DISPATCH_TOPIC_PREFIX}document.`;
@@ -34656,6 +34660,13 @@ async function claimEnvoyRole(sessionID, role, context) {
     throw new Error("Envoy has no bound instance for a role claim");
   await instance.claim(sessionID, role, context);
 }
+async function subscribeLegionNotice(sessionID, topic, context) {
+  const bridge = legionRoleClaimBridge();
+  const instance = bridge.instances.findLast((candidate) => candidate.sessionID() === sessionID) ?? bridge.instances.at(-1);
+  if (instance === undefined)
+    throw new Error("Envoy has no bound instance for a notice subscription");
+  await instance.subscribe(sessionID, topic, context);
+}
 function onEnvoyRoleRegained(listener) {
   legionRoleClaimBridge().regained = listener;
 }
@@ -35190,8 +35201,19 @@ function envoyExtension(pi) {
     await registerSession();
     await setEnvoyRole(role);
   };
+  const subscribeNotice = async (targetSessionID, topic, callerContext) => {
+    const context = callerContext ?? activeSessionContext;
+    if (context === undefined || context.sessionManager.getSessionId() !== targetSessionID) {
+      throw new Error(`Envoy has no active session for Legion notice subscription: ${targetSessionID}`);
+    }
+    if (sessionID !== targetSessionID)
+      await establishSession(context);
+    await subscribe(topic);
+    await registerSession();
+  };
   const claimInstance = {
     claim,
+    subscribe: subscribeNotice,
     sessionID: () => activeSessionContext?.sessionManager.getSessionId() ?? sessionID
   };
   bridge.instances.push(claimInstance);

package/dist/legion.js

@@ -16113,7 +16113,7 @@ var require_mod4 = __commonJS(function(exports) {
 
 // extensions/legion.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import path4 from "path";
+import path5 from "path";
 
 // ../envoy-client/src/defaults.ts
 var DEFAULT_ENVOY_URL = "http://127.0.0.1:9020";
@@ -16144,7 +16144,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "1.60.2",
+  version: "1.61.0",
   type: "module",
   omp: {
     extensions: [
@@ -16157,7 +16157,7 @@ var package_default = {
   },
   legion: {
     daemonApiVersion: 8,
-    goDaemonApiVersion: 1
+    goDaemonApiVersion: 3
   },
   repository: {
     type: "git",
@@ -30544,6 +30544,10 @@ var handoffMessageSchema = object({
 // ../contracts/src/subject.ts
 var AGENT_TOPIC_PREFIX = "notifications.agent.";
 var ROLE_TOPIC_PREFIX = "notifications.role.";
+var LEGION_NOTICE_TOPIC_PREFIX = "notifications.legion.";
+function legionNoticeSubject(project, issue) {
+  return `${LEGION_NOTICE_TOPIC_PREFIX}${project}.${issue}`;
+}
 var DISPATCH_TOPIC_PREFIX = "notifications.dispatch.";
 var DISPATCH_ISSUE_TOPIC_PREFIX = `${DISPATCH_TOPIC_PREFIX}issue.`;
 var DISPATCH_DOCUMENT_TOPIC_PREFIX = `${DISPATCH_TOPIC_PREFIX}document.`;
@@ -31183,6 +31187,13 @@ async function claimEnvoyRole(sessionID, role, context) {
     throw new Error("Envoy has no bound instance for a role claim");
   await instance.claim(sessionID, role, context);
 }
+async function subscribeLegionNotice(sessionID, topic, context) {
+  const bridge = legionRoleClaimBridge();
+  const instance = bridge.instances.findLast((candidate) => candidate.sessionID() === sessionID) ?? bridge.instances.at(-1);
+  if (instance === undefined)
+    throw new Error("Envoy has no bound instance for a notice subscription");
+  await instance.subscribe(sessionID, topic, context);
+}
 function onEnvoyRoleRegained(listener) {
   legionRoleClaimBridge().regained = listener;
 }
@@ -31277,6 +31288,9 @@ async function writeGrantFile(file, grantId) {
   }
 }
 
+// src/legion/go-bootstrap.ts
+import path3 from "path";
+
 // ../contracts/src/legion-go-api.ts
 var nonEmptyString2 = string2().min(1);
 var timestamp = exports_iso.datetime({ offset: true });
@@ -31346,10 +31360,18 @@ var legionGoSlotView = strictObject({
   index: number2().int().nonnegative(),
   admittedAt: timestamp
 });
+var legionGoPendingStatusWrite = strictObject({
+  issue: nonEmptyString2,
+  payload: record(string2(), unknown()),
+  attempts: number2().int().nonnegative(),
+  nextAt: timestamp,
+  lastError: string2().optional()
+});
 var legionGoIssue = strictObject({
   key: nonEmptyString2,
   generation: number2().int().nonnegative(),
   phase: _enum2(LEGION_GO_PHASES),
+  status: nonEmptyString2,
   architect: legionGoClaimView.optional(),
   workers: partialRecord(_enum2(LEGION_ROLES), legionGoPhaseView),
   pullRequest: legionGoPullRequestView.optional(),
@@ -31371,7 +31393,8 @@ var legionGoAdmission = strictObject({
 var LegionGoStateResponse = strictObject({
   daemon: goDaemonInfo,
   admission: legionGoAdmission,
-  issues: record(string2(), legionGoIssue)
+  issues: record(string2(), legionGoIssue),
+  pendingStatusWrites: array(legionGoPendingStatusWrite)
 });
 var LegionGoRegisterResponse = strictObject({
   claimToken: nonEmptyString2,
@@ -31381,9 +31404,10 @@ var LegionGoRegisterResponse = strictObject({
   generation: number2().int().positive(),
   secret: nonEmptyString2
 });
-var LegionGoErrorResponse = strictObject({
-  error: nonEmptyString2
-});
+var LegionGoErrorResponse = union([
+  strictObject({ error: nonEmptyString2 }),
+  strictObject({ code: nonEmptyString2, error: nonEmptyString2 })
+]);
 var legionGoDeliveryView = strictObject({
   id: nonEmptyString2,
   task: nonEmptyString2,
@@ -31412,18 +31436,81 @@ var LegionGoOperatorClaimResponse = strictObject({
 var LegionGoOperatorClaimsResponse = strictObject({
   claims: array(LegionGoOperatorClaimResponse)
 });
+var LegionGoGrantResponse = strictObject({
+  grantId: nonEmptyString2,
+  expiresAt: timestamp
+});
+var LegionGoGitHubTokenResponse = strictObject({
+  token: nonEmptyString2,
+  appLogin: string2().endsWith("[bot]")
+});
+var LegionGoGitCredentialResponse = strictObject({
+  username: literal("x-access-token"),
+  password: nonEmptyString2
+});
+var LegionGoEmptyResponse = strictObject({});
+var LegionGoWaveReleaseResponse = strictObject({
+  released: array(nonEmptyString2)
+});
+var LegionGoGrantRequest = strictObject({
+  sessionId: nonEmptyString2,
+  secret: nonEmptyString2,
+  tree: nonEmptyString2,
+  issue: nonEmptyString2
+});
+var LegionGoGrantCredentialRequest = strictObject({
+  grantId: nonEmptyString2
+});
+var LegionGoHandoffCompleteRequest = strictObject({
+  grantId: nonEmptyString2,
+  summary: nonEmptyString2,
+  verdict: string2(),
+  ready: boolean2(),
+  commit: nonEmptyString2
+});
+var LegionGoIssueStatusRequest = strictObject({
+  grantId: nonEmptyString2,
+  issue: nonEmptyString2,
+  status: _enum2(["todo", "backlog", "icebox"])
+});
+var LegionGoGateRegisterRequest = strictObject({
+  grantId: nonEmptyString2,
+  issue: nonEmptyString2,
+  artifactId: uuid2(),
+  version: number2().int().positive()
+});
+var LegionGoWaveReleaseRequest = strictObject({
+  grantId: nonEmptyString2,
+  issues: array(nonEmptyString2)
+});
+var LegionGoPhaseBackwardRequest = strictObject({
+  grantId: nonEmptyString2,
+  to: _enum2(LEGION_GO_PHASES),
+  reason: nonEmptyString2
+});
+var LegionGoPhaseRetryRequest = strictObject({
+  grantId: nonEmptyString2,
+  issue: nonEmptyString2,
+  decision: _enum2(["retry", "escalate"])
+});
+var LegionGoSignOffRequest = strictObject({
+  grantId: nonEmptyString2,
+  issue: nonEmptyString2
+});
 
 // src/legion/go-daemon-client.ts
 class LegionGoDaemonApiError extends Error {
   method;
   path;
   status;
+  code;
   detail;
-  constructor(method, path, status, detail) {
-    super(`${method} ${path} failed with ${status}: ${detail}`);
+  constructor(method, path, status, code, detail) {
+    super(`${method} ${path} failed with ${status}${code === undefined ? "" : ` ${code}`}: ${detail}`);
     this.method = method;
     this.path = path;
     this.status = status;
+    this.code = code;
     this.detail = detail;
     this.name = "LegionGoDaemonApiError";
   }
@@ -31467,7 +31554,11 @@ function createLegionGoDaemonClient(baseUrl, fetchFn = fetch) {
     if (response.ok)
       return { status: response.status, text };
     const refusal = parseStrictly(LegionGoErrorResponse, text);
-    throw new LegionGoDaemonApiError(method, path, response.status, "value" in refusal ? refusal.value.error : `${JSON.stringify(text)} is not the Go daemon's refusal shape (${refusal.problem})`);
+    if ("value" in refusal) {
+      const code = "code" in refusal.value && typeof refusal.value.code === "string" ? refusal.value.code : undefined;
+      throw new LegionGoDaemonApiError(method, path, response.status, code, refusal.value.error);
+    }
+    throw new LegionGoDaemonApiError(method, path, response.status, undefined, `${JSON.stringify(text)} is not the Go daemon's refusal shape (${refusal.problem})`);
   };
   const read = async (method, path, schema, body) => {
     const { status, text } = await call(method, path, body);
@@ -31477,6 +31568,7 @@ function createLegionGoDaemonClient(baseUrl, fetchFn = fetch) {
     }
     return parsed.value;
   };
+  const post = (path, request, response, body) => read("POST", path, response, request.parse(body));
   const acknowledge = async (path, body) => {
     const { status, text } = await call("POST", path, body);
     if (status !== 204 || text !== "") {
@@ -31487,7 +31579,18 @@ function createLegionGoDaemonClient(baseUrl, fetchFn = fetch) {
     state: () => read("GET", "/legion/v1/state", LegionGoStateResponse),
     register: (input) => read("POST", "/legion/v1/claims/register", LegionGoRegisterResponse, input),
     ready: (input) => acknowledge("/legion/v1/claims/ready", input),
-    exit: (input) => acknowledge("/legion/v1/claims/exit", input)
+    exit: (input) => acknowledge("/legion/v1/claims/exit", input),
+    grant: (input) => post("/legion/v1/grants", LegionGoGrantRequest, LegionGoGrantResponse, input),
+    githubToken: (input) => post("/legion/v1/gh-token", LegionGoGrantCredentialRequest, LegionGoGitHubTokenResponse, input),
+    gitCredential: (input) => post("/legion/v1/git-credential", LegionGoGrantCredentialRequest, LegionGoGitCredentialResponse, input),
+    provisioningCredential: (input) => post("/legion/v1/provisioning-credential", LegionGoGrantCredentialRequest, LegionGoGitHubTokenResponse, input),
+    handoffComplete: (input) => post("/legion/v1/handoff/complete", LegionGoHandoffCompleteRequest, LegionGoEmptyResponse, input),
+    issueStatus: (input) => post("/legion/v1/issues/status", LegionGoIssueStatusRequest, LegionGoEmptyResponse, input),
+    gateRegister: (input) => post("/legion/v1/gates/register", LegionGoGateRegisterRequest, LegionGoEmptyResponse, input),
+    waveRelease: (input) => post("/legion/v1/waves/release", LegionGoWaveReleaseRequest, LegionGoWaveReleaseResponse, input),
+    phaseBackward: (input) => post("/legion/v1/phase/backward", LegionGoPhaseBackwardRequest, LegionGoEmptyResponse, input),
+    phaseRetry: (input) => post("/legion/v1/phase/retry", LegionGoPhaseRetryRequest, LegionGoEmptyResponse, input),
+    signOff: (input) => post("/legion/v1/signoff", LegionGoSignOffRequest, LegionGoEmptyResponse, input)
   };
 }
 
@@ -31592,7 +31695,7 @@ async function bootstrapGoClaim(context, state) {
   if (existing !== undefined)
     return existing;
   const bootToken = requiredSecret(process.env, "LEGION_BOOT_TOKEN");
-  const daemon = createLegionGoDaemonClient(requiredEnvironment(process.env, "LEGION_DAEMON_URL"));
+  const daemon = state.daemon();
   const bootstrap = (async () => {
     const { sessionFile, agentId } = await state.persistedTranscript(context);
     state.recordBootstrappedSession(sessionFile);
@@ -31610,7 +31713,9 @@ async function bootstrapGoClaim(context, state) {
       generation: claim.generation
     };
     try {
-      await exportJjSessionAttribution(sessionFile, requiredEnvironment(process.env, "LEGION_STATE_DIR"));
+      const stateDir = requiredEnvironment(process.env, "LEGION_STATE_DIR");
+      await exportJjSessionAttribution(sessionFile, stateDir);
+      process.env.LEGION_GRANT_FILE = path3.join(stateDir, "secrets", `${claim.claimToken}-grant`);
       state.setCapability({
         kind: "phase-worker",
         sessionID,
@@ -31621,6 +31726,7 @@ async function bootstrapGoClaim(context, state) {
         secret: claim.secret
       });
       await claimEnvoyRole(sessionID, claim.claimToken, context);
+      await subscribeLegionNotice(sessionID, legionNoticeSubject(requiredEnvironment(process.env, "LEGION_PROJECT"), claim.role === "architect" ? claim.tree : claim.issue), context);
       await callGoReadyWithRetry("claims/ready", () => daemon.ready(ready));
       onEnvoyRoleRegained(async (role, reason) => {
         if (role !== claim.claimToken)
@@ -31646,9 +31752,6 @@ async function bootstrapGoClaim(context, state) {
   }
 }
 
-// src/legion/tools.ts
-import { randomUUID as randomUUID2 } from "crypto";
-
 // src/tool-result.ts
 function toolSuccess(text, details = {}) {
   return { content: [{ type: "text", text }], details };
@@ -31657,8 +31760,167 @@ function toolFailure(error) {
   return { content: [{ type: "text", text: messageFor(error) }], details: {}, isError: true };
 }
 
-// src/legion/tools.ts
+// src/legion/go-tools.ts
+var OPERATIONS = {
+  architect: [
+    "register_gate",
+    "release_children",
+    "request_backward_move",
+    "retry_or_escalate",
+    "sign_off",
+    "read_record"
+  ],
+  "phase-worker": ["request_backward_move", "read_record"]
+};
+var OPERATION_FIELDS = {
+  register_gate: ["issue", "artifactId", "version"],
+  release_children: ["issues"],
+  request_backward_move: ["to", "reason"],
+  retry_or_escalate: ["issue", "decision"],
+  sign_off: ["issue"],
+  read_record: ["issue"]
+};
 var jsonSuccess = (details) => toolSuccess(JSON.stringify(details), details);
+function toolSchema(pi) {
+  const z = pi.zod;
+  return z.object({
+    op: z.enum([
+      "register_gate",
+      "release_children",
+      "request_backward_move",
+      "retry_or_escalate",
+      "sign_off",
+      "read_record"
+    ]),
+    issue: z.string().optional(),
+    artifactId: z.string().optional(),
+    version: z.number().optional(),
+    issues: z.array(z.string()).optional(),
+    to: z.enum(LEGION_GO_PHASES).optional(),
+    reason: z.string().optional(),
+    decision: z.enum(["retry", "escalate"]).optional()
+  });
+}
+function requiredString(parameters, operation, name) {
+  const value = parameters[name];
+  if (typeof value !== "string" || value.trim() === "")
+    throw new Error(`${operation} requires ${name}`);
+  return value;
+}
+function assertOperationInput(parameters, operation) {
+  const fields = OPERATION_FIELDS[operation];
+  if (fields === undefined)
+    throw new Error(`Unsupported Go Legion operation: ${operation}`);
+  for (const name of Object.keys(parameters)) {
+    if (name !== "op" && !fields.includes(name)) {
+      throw new Error(`${operation} does not accept field "${name}"`);
+    }
+  }
+}
+async function grantFor(daemon, session) {
+  if (session.secret === undefined) {
+    throw new Error("Go Legion session has no registered claim capability");
+  }
+  return (await daemon.grant({
+    sessionId: session.sessionId,
+    secret: session.secret,
+    tree: session.tree,
+    issue: session.issue
+  })).grantId;
+}
+function recordFrom(state, issue) {
+  const record = state.issues[issue];
+  if (record === undefined)
+    throw new Error(`The Go daemon has no record for ${issue}`);
+  return record;
+}
+function createGoLegionTool(deps) {
+  const { pi, daemon, session } = deps;
+  return {
+    name: "legion",
+    label: "legion",
+    description: "Perform the workflow operation the Go Legion daemon assigned this role. The daemon advances phases; this tool cannot spawn workers.",
+    defaultInactive: true,
+    parameters: toolSchema(pi),
+    execute: async (_id, parameters, _signal, _onUpdate, context) => {
+      try {
+        const active = session(context);
+        const operation = requiredString(parameters, "legion", "op");
+        if (!OPERATIONS[active.kind].includes(operation)) {
+          throw new Error(`${operation} is not available to a ${active.kind} session`);
+        }
+        assertOperationInput(parameters, operation);
+        const client = daemon();
+        switch (operation) {
+          case "read_record": {
+            const issue = requiredString(parameters, operation, "issue");
+            return jsonSuccess({ record: recordFrom(await client.state(), issue) });
+          }
+          case "register_gate": {
+            const version = parameters.version;
+            if (typeof version !== "number" || !Number.isSafeInteger(version) || version < 1) {
+              throw new Error("register_gate requires a positive integer version");
+            }
+            const grantId = await grantFor(client, active);
+            await client.gateRegister({
+              grantId,
+              issue: requiredString(parameters, operation, "issue"),
+              artifactId: requiredString(parameters, operation, "artifactId"),
+              version
+            });
+            return jsonSuccess({});
+          }
+          case "release_children": {
+            const issues = parameters.issues;
+            if (!Array.isArray(issues) || !issues.every((issue) => typeof issue === "string")) {
+              throw new Error("release_children requires issues");
+            }
+            const grantId = await grantFor(client, active);
+            return jsonSuccess(await client.waveRelease({ grantId, issues }));
+          }
+          case "request_backward_move": {
+            const grantId = await grantFor(client, active);
+            await client.phaseBackward({
+              grantId,
+              to: requiredString(parameters, operation, "to"),
+              reason: requiredString(parameters, operation, "reason")
+            });
+            return jsonSuccess({});
+          }
+          case "retry_or_escalate": {
+            const decision = parameters.decision;
+            if (decision !== "retry" && decision !== "escalate") {
+              throw new Error("retry_or_escalate requires decision retry or escalate");
+            }
+            const grantId = await grantFor(client, active);
+            await client.phaseRetry({
+              grantId,
+              issue: requiredString(parameters, operation, "issue"),
+              decision
+            });
+            return jsonSuccess({});
+          }
+          case "sign_off": {
+            const grantId = await grantFor(client, active);
+            await client.signOff({
+              grantId,
+              issue: requiredString(parameters, operation, "issue")
+            });
+            return jsonSuccess({});
+          }
+          default:
+            throw new Error(`Unsupported Go Legion operation: ${operation}`);
+        }
+      } catch (error) {
+        return toolFailure(error);
+      }
+    }
+  };
+}
+
+// src/legion/tools.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var jsonSuccess2 = (details) => toolSuccess(JSON.stringify(details), details);
 function isDispatchArtifactId(value) {
   return LegionDaemonApi.GatesRegister.request.shape.artifactId.safeParse(value).success;
 }
@@ -31726,7 +31988,7 @@ function createLegionTool(deps) {
               issue: stringInput("issue"),
               status
             });
-            return jsonSuccess({});
+            return jsonSuccess2({});
           }
           case "register_gate": {
             const version = parameters.version;
@@ -31745,14 +32007,14 @@ function createLegionTool(deps) {
               artifactId,
               version
             });
-            return jsonSuccess({});
+            return jsonSuccess2({});
           }
           case "release_wave": {
             const issues = parameters.issues;
             if (!Array.isArray(issues) || !issues.every((issue) => typeof issue === "string")) {
               throw new Error("release_wave requires issues");
             }
-            return jsonSuccess(await daemon.releaseWave({
+            return jsonSuccess2(await daemon.releaseWave({
               tree: architect.tree,
               issues,
               sessionId,
@@ -31773,7 +32035,7 @@ function createLegionTool(deps) {
               sessionId,
               secret: architect.secret
             });
-            return jsonSuccess({});
+            return jsonSuccess2({});
           }
           case "spawn_worker": {
             const role = parameters.role;
@@ -31781,7 +32043,7 @@ function createLegionTool(deps) {
               throw new Error("spawn_worker requires a valid Legion role");
             }
             const requestId = randomUUID2();
-            return jsonSuccess(await daemon.spawnWorker({
+            return jsonSuccess2(await daemon.spawnWorker({
               tree: architect.tree,
               sessionId,
               secret: architect.secret,
@@ -31803,7 +32065,7 @@ function createLegionTool(deps) {
 
 // src/subagent-session.ts
 import fs from "fs";
-import path3 from "path";
+import path4 from "path";
 import * as host from "@oh-my-pi/pi-coding-agent";
 var LEGION_BOOTSTRAPPED_SESSION = Symbol.for("legion.pi-envoy.bootstrapped-session");
 var bootstrappedSessionStore = globalThis;
@@ -31814,7 +32076,7 @@ async function isSubagentSession(context) {
   await context.sessionManager.ensureOnDisk();
   const sessionFile = context.sessionManager.getSessionFile();
   if (sessionFile !== undefined && fs.existsSync(sessionFile)) {
-    return fs.existsSync(`${path3.dirname(sessionFile)}.jsonl`);
+    return fs.existsSync(`${path4.dirname(sessionFile)}.jsonl`);
   }
   const bootstrapped = bootstrappedSessionStore[LEGION_BOOTSTRAPPED_SESSION];
   return bootstrapped !== undefined && bootstrapped !== sessionFile;
@@ -31900,7 +32162,7 @@ async function persistedTranscript(context) {
   if (!sessionFile?.endsWith(".jsonl")) {
     throw new Error("Legion session must have a persisted transcript");
   }
-  const agentId = path4.basename(sessionFile, ".jsonl");
+  const agentId = path5.basename(sessionFile, ".jsonl");
   if (!agentId)
     throw new Error("Legion session transcript has no agent id");
   return { sessionFile, agentId };
@@ -32075,6 +32337,11 @@ function legionExtension(pi) {
     });
     return daemonClient;
   };
+  let goDaemonClient;
+  const goRoleDaemon = () => {
+    goDaemonClient ??= createLegionGoDaemonClient(requiredEnvironment(process.env, "LEGION_DAEMON_URL"));
+    return goDaemonClient;
+  };
   const rerunReadyAfterRegain = async (endpoint, role, reason, call) => {
     try {
       await callReadyWithRetry(`${endpoint} after role regain`, call);
@@ -32286,7 +32553,7 @@ function legionExtension(pi) {
     if (await checkSubagentSession(context))
       return;
     if (process.env.LEGION_DAEMON_API === "go") {
-      return bootstrapGoClaim(context, {
+      await bootstrapGoClaim(context, {
         capability: () => capability,
         setCapability: (next) => {
           capability = next;
@@ -32295,10 +32562,14 @@ function legionExtension(pi) {
         setBootstrap: (next) => {
           bootstrap = next;
         },
+        daemon: goRoleDaemon,
         exitProcess,
         persistedTranscript,
         recordBootstrappedSession
       });
+      registerGoTools();
+      await activateLegionTool();
+      return;
     }
     const classification = classifySession(process.env);
     switch (classification.kind) {
@@ -32373,7 +32644,12 @@ function legionExtension(pi) {
       }
       return;
     }
-    return wrapBashWithGrant(() => roleDaemon().grant({
+    return wrapBashWithGrant(() => process.env.LEGION_DAEMON_API === "go" ? goRoleDaemon().grant({
+      tree: active.tree,
+      issue: active.issue,
+      sessionId: sessionID,
+      secret: active.secret
+    }) : roleDaemon().grant({
       tree: active.tree,
       issue: active.issue,
       sessionId: sessionID,
@@ -32424,6 +32700,30 @@ function legionExtension(pi) {
     architectToolsRegistered = true;
     pi.registerTool(createLegionTool({ pi, roleDaemon, architectSession }));
   };
+  let goToolsRegistered = false;
+  const registerGoTools = () => {
+    if (goToolsRegistered)
+      return;
+    goToolsRegistered = true;
+    pi.registerTool(createGoLegionTool({
+      pi,
+      daemon: goRoleDaemon,
+      session: (context) => {
+        const sessionID = context.sessionManager.getSessionId();
+        const active = capability;
+        if (active === undefined || active.sessionID !== sessionID) {
+          throw new Error("Go Legion tool is available only to this session's registered claim");
+        }
+        return {
+          kind: active.role === "architect" ? "architect" : "phase-worker",
+          sessionId: active.sessionID,
+          tree: active.tree,
+          issue: active.issue,
+          secret: active.secret
+        };
+      }
+    }));
+  };
   pi.registerCommand("legion-claim-controller", {
     description: "Claim the Legion controller role and register daemon authority for this session",
     handler: async (_args, context) => controllerSession.claim(context)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "1.60.2",
+  "version": "1.61.0",
   "type": "module",
   "omp": {
     "extensions": [
@@ -13,7 +13,7 @@
   },
   "legion": {
     "daemonApiVersion": 8,
-    "goDaemonApiVersion": 1
+    "goDaemonApiVersion": 3
   },
   "repository": {
     "type": "git",