@sjawhar/pi-legion-envoy 1.59.1 → 1.60.1

package/dist/envoy.js

@@ -29783,6 +29783,7 @@ var MessageEventPayloadSchema = object({
   target: string2().nullish(),
   in_reply_to: string2().nullish(),
   reply_body: string2().optional(),
+  thread_target: string2().optional(),
   author: object({ kind: string2(), id: string2() }).optional()
 });
 var DispatchTargetedResourceIDSchema = uuid2();

package/dist/legion.js

@@ -16144,7 +16144,7 @@ import { logger } from "@oh-my-pi/pi-utils";
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion-envoy",
-  version: "1.59.1",
+  version: "1.60.1",
   type: "module",
   omp: {
     extensions: [
@@ -16156,7 +16156,8 @@ var package_default = {
     ]
   },
   legion: {
-    daemonApiVersion: 8
+    daemonApiVersion: 8,
+    goDaemonApiVersion: 1
   },
   repository: {
     type: "git",
@@ -16187,6 +16188,247 @@ var package_default = {
   }
 };
 
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
+var exports_external = {};
+__export(exports_external, {
+  $brand: () => $brand,
+  $input: () => $input,
+  $output: () => $output,
+  NEVER: () => NEVER,
+  TimePrecision: () => TimePrecision,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBase64: () => ZodBase64,
+  ZodBase64URL: () => ZodBase64URL,
+  ZodBigInt: () => ZodBigInt,
+  ZodBigIntFormat: () => ZodBigIntFormat,
+  ZodBoolean: () => ZodBoolean,
+  ZodCIDRv4: () => ZodCIDRv4,
+  ZodCIDRv6: () => ZodCIDRv6,
+  ZodCUID: () => ZodCUID,
+  ZodCUID2: () => ZodCUID2,
+  ZodCatch: () => ZodCatch,
+  ZodCodec: () => ZodCodec,
+  ZodCustom: () => ZodCustom,
+  ZodCustomStringFormat: () => ZodCustomStringFormat,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodE164: () => ZodE164,
+  ZodEmail: () => ZodEmail,
+  ZodEmoji: () => ZodEmoji,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodExactOptional: () => ZodExactOptional,
+  ZodFile: () => ZodFile,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodGUID: () => ZodGUID,
+  ZodIPv4: () => ZodIPv4,
+  ZodIPv6: () => ZodIPv6,
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodJWT: () => ZodJWT,
+  ZodKSUID: () => ZodKSUID,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMAC: () => ZodMAC,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNanoID: () => ZodNanoID,
+  ZodNever: () => ZodNever,
+  ZodNonOptional: () => ZodNonOptional,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodNumberFormat: () => ZodNumberFormat,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodPipe: () => ZodPipe,
+  ZodPrefault: () => ZodPrefault,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRealError: () => ZodRealError,
+  ZodRecord: () => ZodRecord,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodStringFormat: () => ZodStringFormat,
+  ZodSuccess: () => ZodSuccess,
+  ZodSymbol: () => ZodSymbol,
+  ZodTemplateLiteral: () => ZodTemplateLiteral,
+  ZodTransform: () => ZodTransform,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodULID: () => ZodULID,
+  ZodURL: () => ZodURL,
+  ZodUUID: () => ZodUUID,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  ZodXID: () => ZodXID,
+  ZodXor: () => ZodXor,
+  _ZodString: () => _ZodString,
+  _default: () => _default2,
+  _function: () => _function,
+  any: () => any,
+  array: () => array,
+  base64: () => base642,
+  base64url: () => base64url2,
+  bigint: () => bigint2,
+  boolean: () => boolean2,
+  catch: () => _catch2,
+  check: () => check,
+  cidrv4: () => cidrv42,
+  cidrv6: () => cidrv62,
+  clone: () => clone,
+  codec: () => codec,
+  coerce: () => exports_coerce,
+  config: () => config,
+  core: () => exports_core2,
+  cuid: () => cuid3,
+  cuid2: () => cuid22,
+  custom: () => custom,
+  date: () => date3,
+  decode: () => decode2,
+  decodeAsync: () => decodeAsync2,
+  describe: () => describe2,
+  discriminatedUnion: () => discriminatedUnion,
+  e164: () => e1642,
+  email: () => email2,
+  emoji: () => emoji2,
+  encode: () => encode2,
+  encodeAsync: () => encodeAsync2,
+  endsWith: () => _endsWith,
+  enum: () => _enum2,
+  exactOptional: () => exactOptional,
+  file: () => file,
+  flattenError: () => flattenError,
+  float32: () => float32,
+  float64: () => float64,
+  formatError: () => formatError,
+  fromJSONSchema: () => fromJSONSchema,
+  function: () => _function,
+  getErrorMap: () => getErrorMap,
+  globalRegistry: () => globalRegistry,
+  gt: () => _gt,
+  gte: () => _gte,
+  guid: () => guid2,
+  hash: () => hash,
+  hex: () => hex2,
+  hostname: () => hostname2,
+  httpUrl: () => httpUrl,
+  includes: () => _includes,
+  instanceof: () => _instanceof,
+  int: () => int,
+  int32: () => int32,
+  int64: () => int64,
+  intersection: () => intersection,
+  ipv4: () => ipv42,
+  ipv6: () => ipv62,
+  iso: () => exports_iso,
+  json: () => json,
+  jwt: () => jwt,
+  keyof: () => keyof,
+  ksuid: () => ksuid2,
+  lazy: () => lazy,
+  length: () => _length,
+  literal: () => literal,
+  locales: () => exports_locales,
+  looseObject: () => looseObject,
+  looseRecord: () => looseRecord,
+  lowercase: () => _lowercase,
+  lt: () => _lt,
+  lte: () => _lte,
+  mac: () => mac2,
+  map: () => map,
+  maxLength: () => _maxLength,
+  maxSize: () => _maxSize,
+  meta: () => meta2,
+  mime: () => _mime,
+  minLength: () => _minLength,
+  minSize: () => _minSize,
+  multipleOf: () => _multipleOf,
+  nan: () => nan,
+  nanoid: () => nanoid2,
+  nativeEnum: () => nativeEnum,
+  negative: () => _negative,
+  never: () => never,
+  nonnegative: () => _nonnegative,
+  nonoptional: () => nonoptional,
+  nonpositive: () => _nonpositive,
+  normalize: () => _normalize,
+  null: () => _null3,
+  nullable: () => nullable,
+  nullish: () => nullish2,
+  number: () => number2,
+  object: () => object,
+  optional: () => optional,
+  overwrite: () => _overwrite,
+  parse: () => parse3,
+  parseAsync: () => parseAsync2,
+  partialRecord: () => partialRecord,
+  pipe: () => pipe,
+  positive: () => _positive,
+  prefault: () => prefault,
+  preprocess: () => preprocess,
+  prettifyError: () => prettifyError,
+  promise: () => promise,
+  property: () => _property,
+  readonly: () => readonly,
+  record: () => record,
+  refine: () => refine,
+  regex: () => _regex,
+  regexes: () => exports_regexes,
+  registry: () => registry,
+  safeDecode: () => safeDecode2,
+  safeDecodeAsync: () => safeDecodeAsync2,
+  safeEncode: () => safeEncode2,
+  safeEncodeAsync: () => safeEncodeAsync2,
+  safeParse: () => safeParse2,
+  safeParseAsync: () => safeParseAsync2,
+  set: () => set,
+  setErrorMap: () => setErrorMap,
+  size: () => _size,
+  slugify: () => _slugify,
+  startsWith: () => _startsWith,
+  strictObject: () => strictObject,
+  string: () => string2,
+  stringFormat: () => stringFormat,
+  stringbool: () => stringbool,
+  success: () => success,
+  superRefine: () => superRefine,
+  symbol: () => symbol,
+  templateLiteral: () => templateLiteral,
+  toJSONSchema: () => toJSONSchema,
+  toLowerCase: () => _toLowerCase,
+  toUpperCase: () => _toUpperCase,
+  transform: () => transform,
+  treeifyError: () => treeifyError,
+  trim: () => _trim,
+  tuple: () => tuple,
+  uint32: () => uint32,
+  uint64: () => uint64,
+  ulid: () => ulid2,
+  undefined: () => _undefined3,
+  union: () => union,
+  unknown: () => unknown,
+  uppercase: () => _uppercase,
+  url: () => url,
+  util: () => exports_util,
+  uuid: () => uuid2,
+  uuidv4: () => uuidv4,
+  uuidv6: () => uuidv6,
+  uuidv7: () => uuidv7,
+  void: () => _void2,
+  xid: () => xid2,
+  xor: () => xor
+});
+
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/index.js
 var exports_core2 = {};
 __export(exports_core2, {
@@ -28966,6 +29208,518 @@ function json(params) {
 function preprocess(fn, schema) {
   return pipe(transform(fn), schema);
 }
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/compat.js
+var ZodIssueCode = {
+  invalid_type: "invalid_type",
+  too_big: "too_big",
+  too_small: "too_small",
+  invalid_format: "invalid_format",
+  not_multiple_of: "not_multiple_of",
+  unrecognized_keys: "unrecognized_keys",
+  invalid_union: "invalid_union",
+  invalid_key: "invalid_key",
+  invalid_element: "invalid_element",
+  invalid_value: "invalid_value",
+  custom: "custom"
+};
+function setErrorMap(map) {
+  config({
+    customError: map
+  });
+}
+function getErrorMap() {
+  return config().customError;
+}
+var ZodFirstPartyTypeKind;
+(function(ZodFirstPartyTypeKind) {})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/from-json-schema.js
+var z = {
+  ...exports_schemas2,
+  ...exports_checks2,
+  iso: exports_iso
+};
+var RECOGNIZED_KEYS = new Set([
+  "$schema",
+  "$ref",
+  "$defs",
+  "definitions",
+  "$id",
+  "id",
+  "$comment",
+  "$anchor",
+  "$vocabulary",
+  "$dynamicRef",
+  "$dynamicAnchor",
+  "type",
+  "enum",
+  "const",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "not",
+  "properties",
+  "required",
+  "additionalProperties",
+  "patternProperties",
+  "propertyNames",
+  "minProperties",
+  "maxProperties",
+  "items",
+  "prefixItems",
+  "additionalItems",
+  "minItems",
+  "maxItems",
+  "uniqueItems",
+  "contains",
+  "minContains",
+  "maxContains",
+  "minLength",
+  "maxLength",
+  "pattern",
+  "format",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf",
+  "description",
+  "default",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "if",
+  "then",
+  "else",
+  "dependentSchemas",
+  "dependentRequired",
+  "nullable",
+  "readOnly"
+]);
+function detectVersion(schema, defaultTarget) {
+  const $schema = schema.$schema;
+  if ($schema === "https://json-schema.org/draft/2020-12/schema") {
+    return "draft-2020-12";
+  }
+  if ($schema === "http://json-schema.org/draft-07/schema#") {
+    return "draft-7";
+  }
+  if ($schema === "http://json-schema.org/draft-04/schema#") {
+    return "draft-4";
+  }
+  return defaultTarget ?? "draft-2020-12";
+}
+function resolveRef(ref, ctx) {
+  if (!ref.startsWith("#")) {
+    throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
+  }
+  const path = ref.slice(1).split("/").filter(Boolean);
+  if (path.length === 0) {
+    return ctx.rootSchema;
+  }
+  const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
+  if (path[0] === defsKey) {
+    const key = path[1];
+    if (!key || !ctx.defs[key]) {
+      throw new Error(`Reference not found: ${ref}`);
+    }
+    return ctx.defs[key];
+  }
+  throw new Error(`Reference not found: ${ref}`);
+}
+function convertBaseSchema(schema, ctx) {
+  if (schema.not !== undefined) {
+    if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
+      return z.never();
+    }
+    throw new Error("not is not supported in Zod (except { not: {} } for never)");
+  }
+  if (schema.unevaluatedItems !== undefined) {
+    throw new Error("unevaluatedItems is not supported");
+  }
+  if (schema.unevaluatedProperties !== undefined) {
+    throw new Error("unevaluatedProperties is not supported");
+  }
+  if (schema.if !== undefined || schema.then !== undefined || schema.else !== undefined) {
+    throw new Error("Conditional schemas (if/then/else) are not supported");
+  }
+  if (schema.dependentSchemas !== undefined || schema.dependentRequired !== undefined) {
+    throw new Error("dependentSchemas and dependentRequired are not supported");
+  }
+  if (schema.$ref) {
+    const refPath = schema.$ref;
+    if (ctx.refs.has(refPath)) {
+      return ctx.refs.get(refPath);
+    }
+    if (ctx.processing.has(refPath)) {
+      return z.lazy(() => {
+        if (!ctx.refs.has(refPath)) {
+          throw new Error(`Circular reference not resolved: ${refPath}`);
+        }
+        return ctx.refs.get(refPath);
+      });
+    }
+    ctx.processing.add(refPath);
+    const resolved = resolveRef(refPath, ctx);
+    const zodSchema = convertSchema(resolved, ctx);
+    ctx.refs.set(refPath, zodSchema);
+    ctx.processing.delete(refPath);
+    return zodSchema;
+  }
+  if (schema.enum !== undefined) {
+    const enumValues = schema.enum;
+    if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
+      return z.null();
+    }
+    if (enumValues.length === 0) {
+      return z.never();
+    }
+    if (enumValues.length === 1) {
+      return z.literal(enumValues[0]);
+    }
+    if (enumValues.every((v) => typeof v === "string")) {
+      return z.enum(enumValues);
+    }
+    const literalSchemas = enumValues.map((v) => z.literal(v));
+    if (literalSchemas.length < 2) {
+      return literalSchemas[0];
+    }
+    return z.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+  }
+  if (schema.const !== undefined) {
+    return z.literal(schema.const);
+  }
+  const type = schema.type;
+  if (Array.isArray(type)) {
+    const typeSchemas = type.map((t) => {
+      const typeSchema = { ...schema, type: t };
+      return convertBaseSchema(typeSchema, ctx);
+    });
+    if (typeSchemas.length === 0) {
+      return z.never();
+    }
+    if (typeSchemas.length === 1) {
+      return typeSchemas[0];
+    }
+    return z.union(typeSchemas);
+  }
+  if (!type) {
+    return z.any();
+  }
+  let zodSchema;
+  switch (type) {
+    case "string": {
+      let stringSchema = z.string();
+      if (schema.format) {
+        const format = schema.format;
+        if (format === "email") {
+          stringSchema = stringSchema.check(z.email());
+        } else if (format === "uri" || format === "uri-reference") {
+          stringSchema = stringSchema.check(z.url());
+        } else if (format === "uuid" || format === "guid") {
+          stringSchema = stringSchema.check(z.uuid());
+        } else if (format === "date-time") {
+          stringSchema = stringSchema.check(z.iso.datetime());
+        } else if (format === "date") {
+          stringSchema = stringSchema.check(z.iso.date());
+        } else if (format === "time") {
+          stringSchema = stringSchema.check(z.iso.time());
+        } else if (format === "duration") {
+          stringSchema = stringSchema.check(z.iso.duration());
+        } else if (format === "ipv4") {
+          stringSchema = stringSchema.check(z.ipv4());
+        } else if (format === "ipv6") {
+          stringSchema = stringSchema.check(z.ipv6());
+        } else if (format === "mac") {
+          stringSchema = stringSchema.check(z.mac());
+        } else if (format === "cidr") {
+          stringSchema = stringSchema.check(z.cidrv4());
+        } else if (format === "cidr-v6") {
+          stringSchema = stringSchema.check(z.cidrv6());
+        } else if (format === "base64") {
+          stringSchema = stringSchema.check(z.base64());
+        } else if (format === "base64url") {
+          stringSchema = stringSchema.check(z.base64url());
+        } else if (format === "e164") {
+          stringSchema = stringSchema.check(z.e164());
+        } else if (format === "jwt") {
+          stringSchema = stringSchema.check(z.jwt());
+        } else if (format === "emoji") {
+          stringSchema = stringSchema.check(z.emoji());
+        } else if (format === "nanoid") {
+          stringSchema = stringSchema.check(z.nanoid());
+        } else if (format === "cuid") {
+          stringSchema = stringSchema.check(z.cuid());
+        } else if (format === "cuid2") {
+          stringSchema = stringSchema.check(z.cuid2());
+        } else if (format === "ulid") {
+          stringSchema = stringSchema.check(z.ulid());
+        } else if (format === "xid") {
+          stringSchema = stringSchema.check(z.xid());
+        } else if (format === "ksuid") {
+          stringSchema = stringSchema.check(z.ksuid());
+        }
+      }
+      if (typeof schema.minLength === "number") {
+        stringSchema = stringSchema.min(schema.minLength);
+      }
+      if (typeof schema.maxLength === "number") {
+        stringSchema = stringSchema.max(schema.maxLength);
+      }
+      if (schema.pattern) {
+        stringSchema = stringSchema.regex(new RegExp(schema.pattern));
+      }
+      zodSchema = stringSchema;
+      break;
+    }
+    case "number":
+    case "integer": {
+      let numberSchema = type === "integer" ? z.number().int() : z.number();
+      if (typeof schema.minimum === "number") {
+        numberSchema = numberSchema.min(schema.minimum);
+      }
+      if (typeof schema.maximum === "number") {
+        numberSchema = numberSchema.max(schema.maximum);
+      }
+      if (typeof schema.exclusiveMinimum === "number") {
+        numberSchema = numberSchema.gt(schema.exclusiveMinimum);
+      } else if (schema.exclusiveMinimum === true && typeof schema.minimum === "number") {
+        numberSchema = numberSchema.gt(schema.minimum);
+      }
+      if (typeof schema.exclusiveMaximum === "number") {
+        numberSchema = numberSchema.lt(schema.exclusiveMaximum);
+      } else if (schema.exclusiveMaximum === true && typeof schema.maximum === "number") {
+        numberSchema = numberSchema.lt(schema.maximum);
+      }
+      if (typeof schema.multipleOf === "number") {
+        numberSchema = numberSchema.multipleOf(schema.multipleOf);
+      }
+      zodSchema = numberSchema;
+      break;
+    }
+    case "boolean": {
+      zodSchema = z.boolean();
+      break;
+    }
+    case "null": {
+      zodSchema = z.null();
+      break;
+    }
+    case "object": {
+      const shape = {};
+      const properties = schema.properties || {};
+      const requiredSet = new Set(schema.required || []);
+      for (const [key, propSchema] of Object.entries(properties)) {
+        const propZodSchema = convertSchema(propSchema, ctx);
+        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+      }
+      if (schema.propertyNames) {
+        const keySchema = convertSchema(schema.propertyNames, ctx);
+        const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z.any();
+        if (Object.keys(shape).length === 0) {
+          zodSchema = z.record(keySchema, valueSchema);
+          break;
+        }
+        const objectSchema = z.object(shape).passthrough();
+        const recordSchema = z.looseRecord(keySchema, valueSchema);
+        zodSchema = z.intersection(objectSchema, recordSchema);
+        break;
+      }
+      if (schema.patternProperties) {
+        const patternProps = schema.patternProperties;
+        const patternKeys = Object.keys(patternProps);
+        const looseRecords = [];
+        for (const pattern of patternKeys) {
+          const patternValue = convertSchema(patternProps[pattern], ctx);
+          const keySchema = z.string().regex(new RegExp(pattern));
+          looseRecords.push(z.looseRecord(keySchema, patternValue));
+        }
+        const schemasToIntersect = [];
+        if (Object.keys(shape).length > 0) {
+          schemasToIntersect.push(z.object(shape).passthrough());
+        }
+        schemasToIntersect.push(...looseRecords);
+        if (schemasToIntersect.length === 0) {
+          zodSchema = z.object({}).passthrough();
+        } else if (schemasToIntersect.length === 1) {
+          zodSchema = schemasToIntersect[0];
+        } else {
+          let result = z.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+          for (let i = 2;i < schemasToIntersect.length; i++) {
+            result = z.intersection(result, schemasToIntersect[i]);
+          }
+          zodSchema = result;
+        }
+        break;
+      }
+      const objectSchema = z.object(shape);
+      if (schema.additionalProperties === false) {
+        zodSchema = objectSchema.strict();
+      } else if (typeof schema.additionalProperties === "object") {
+        zodSchema = objectSchema.catchall(convertSchema(schema.additionalProperties, ctx));
+      } else {
+        zodSchema = objectSchema.passthrough();
+      }
+      break;
+    }
+    case "array": {
+      const prefixItems = schema.prefixItems;
+      const items = schema.items;
+      if (prefixItems && Array.isArray(prefixItems)) {
+        const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
+        const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : undefined;
+        if (rest) {
+          zodSchema = z.tuple(tupleItems).rest(rest);
+        } else {
+          zodSchema = z.tuple(tupleItems);
+        }
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        }
+      } else if (Array.isArray(items)) {
+        const tupleItems = items.map((item) => convertSchema(item, ctx));
+        const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : undefined;
+        if (rest) {
+          zodSchema = z.tuple(tupleItems).rest(rest);
+        } else {
+          zodSchema = z.tuple(tupleItems);
+        }
+        if (typeof schema.minItems === "number") {
+          zodSchema = zodSchema.check(z.minLength(schema.minItems));
+        }
+        if (typeof schema.maxItems === "number") {
+          zodSchema = zodSchema.check(z.maxLength(schema.maxItems));
+        }
+      } else if (items !== undefined) {
+        const element = convertSchema(items, ctx);
+        let arraySchema = z.array(element);
+        if (typeof schema.minItems === "number") {
+          arraySchema = arraySchema.min(schema.minItems);
+        }
+        if (typeof schema.maxItems === "number") {
+          arraySchema = arraySchema.max(schema.maxItems);
+        }
+        zodSchema = arraySchema;
+      } else {
+        zodSchema = z.array(z.any());
+      }
+      break;
+    }
+    default:
+      throw new Error(`Unsupported type: ${type}`);
+  }
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  if (schema.default !== undefined) {
+    zodSchema = zodSchema.default(schema.default);
+  }
+  return zodSchema;
+}
+function convertSchema(schema, ctx) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
+  }
+  let baseSchema = convertBaseSchema(schema, ctx);
+  const hasExplicitType = schema.type || schema.enum !== undefined || schema.const !== undefined;
+  if (schema.anyOf && Array.isArray(schema.anyOf)) {
+    const options = schema.anyOf.map((s) => convertSchema(s, ctx));
+    const anyOfUnion = z.union(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+  }
+  if (schema.oneOf && Array.isArray(schema.oneOf)) {
+    const options = schema.oneOf.map((s) => convertSchema(s, ctx));
+    const oneOfUnion = z.xor(options);
+    baseSchema = hasExplicitType ? z.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+  }
+  if (schema.allOf && Array.isArray(schema.allOf)) {
+    if (schema.allOf.length === 0) {
+      baseSchema = hasExplicitType ? baseSchema : z.any();
+    } else {
+      let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
+      const startIdx = hasExplicitType ? 0 : 1;
+      for (let i = startIdx;i < schema.allOf.length; i++) {
+        result = z.intersection(result, convertSchema(schema.allOf[i], ctx));
+      }
+      baseSchema = result;
+    }
+  }
+  if (schema.nullable === true && ctx.version === "openapi-3.0") {
+    baseSchema = z.nullable(baseSchema);
+  }
+  if (schema.readOnly === true) {
+    baseSchema = z.readonly(baseSchema);
+  }
+  const extraMeta = {};
+  const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
+  for (const key of coreMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
+    }
+  }
+  const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
+  for (const key of contentMetadataKeys) {
+    if (key in schema) {
+      extraMeta[key] = schema[key];
+    }
+  }
+  for (const key of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key)) {
+      extraMeta[key] = schema[key];
+    }
+  }
+  if (Object.keys(extraMeta).length > 0) {
+    ctx.registry.add(baseSchema, extraMeta);
+  }
+  return baseSchema;
+}
+function fromJSONSchema(schema, params) {
+  if (typeof schema === "boolean") {
+    return schema ? z.any() : z.never();
+  }
+  const version = detectVersion(schema, params?.defaultTarget);
+  const defs = schema.$defs || schema.definitions || {};
+  const ctx = {
+    version,
+    defs,
+    refs: new Map,
+    processing: new Set,
+    rootSchema: schema,
+    registry: params?.registry ?? globalRegistry
+  };
+  return convertSchema(schema, ctx);
+}
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/coerce.js
+var exports_coerce = {};
+__export(exports_coerce, {
+  bigint: () => bigint3,
+  boolean: () => boolean3,
+  date: () => date4,
+  number: () => number3,
+  string: () => string3
+});
+function string3(params) {
+  return _coercedString(ZodString, params);
+}
+function number3(params) {
+  return _coercedNumber(ZodNumber, params);
+}
+function boolean3(params) {
+  return _coercedBoolean(ZodBoolean, params);
+}
+function bigint3(params) {
+  return _coercedBigint(ZodBigInt, params);
+}
+function date4(params) {
+  return _coercedDate(ZodDate, params);
+}
+
+// ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/external.js
+config(en_default());
 // ../contracts/src/dispatch-api.ts
 function serviceSubjectLabel(subject) {
   const parts = subject.split(":");
@@ -29101,6 +29855,7 @@ var MessageEventPayloadSchema = object({
   target: string2().nullish(),
   in_reply_to: string2().nullish(),
   reply_body: string2().optional(),
+  thread_target: string2().optional(),
   author: object({ kind: string2(), id: string2() }).optional()
 });
 var DispatchTargetedResourceIDSchema = uuid2();
@@ -30499,6 +31254,220 @@ async function writeGrantFile(file, grantId) {
   }
 }
 
+// ../contracts/src/legion-go-api.ts
+var nonEmptyString2 = string2().min(1);
+var timestamp = exports_iso.datetime({ offset: true });
+var LEGION_GO_PHASES = [
+  "admitted",
+  "planning",
+  "implementing",
+  "testing",
+  "reviewing",
+  "retro",
+  "merging",
+  "awaiting_merge",
+  "production_check",
+  "done",
+  "held"
+];
+var LEGION_GO_CLAIM_STATES = [
+  "queued",
+  "launch_uncertain",
+  "launching",
+  "shim_connected",
+  "registered",
+  "ready",
+  "working",
+  "idle",
+  "suspended",
+  "failed",
+  "retired"
+];
+var legionGoLocator = discriminatedUnion("runtime", [
+  strictObject({
+    runtime: literal("tmux"),
+    claim: nonEmptyString2,
+    incarnation: nonEmptyString2,
+    tmux: strictObject({ window: nonEmptyString2, pane: nonEmptyString2 })
+  }),
+  strictObject({
+    runtime: literal("sandbox"),
+    claim: nonEmptyString2,
+    incarnation: nonEmptyString2,
+    sandbox: strictObject({ namespace: nonEmptyString2, name: nonEmptyString2 })
+  })
+]);
+var legionGoClaimView = strictObject({
+  session: string2(),
+  state: _enum2(LEGION_GO_CLAIM_STATES),
+  locator: legionGoLocator.optional()
+});
+var legionGoPhaseView = strictObject({
+  claim: legionGoClaimView,
+  handoffCommit: nonEmptyString2.optional(),
+  rounds: number2().int().nonnegative()
+});
+var legionGoPullRequestView = strictObject({
+  number: number2().int().positive(),
+  head: nonEmptyString2,
+  checksVerdict: nonEmptyString2.optional(),
+  reviewDecision: nonEmptyString2.optional(),
+  fixAttempts: number2().int().nonnegative()
+});
+var legionGoGateView = strictObject({
+  artifactId: nonEmptyString2,
+  currentVersion: number2().int().positive(),
+  approvedVersion: number2().int().positive().nullable()
+});
+var legionGoSlotView = strictObject({
+  index: number2().int().nonnegative(),
+  admittedAt: timestamp
+});
+var legionGoIssue = strictObject({
+  key: nonEmptyString2,
+  generation: number2().int().nonnegative(),
+  phase: _enum2(LEGION_GO_PHASES),
+  architect: legionGoClaimView.optional(),
+  workers: partialRecord(_enum2(LEGION_ROLES), legionGoPhaseView),
+  pullRequest: legionGoPullRequestView.optional(),
+  designGate: legionGoGateView.optional(),
+  slot: legionGoSlotView.optional()
+});
+var goDaemonInfo = strictObject({
+  project: nonEmptyString2,
+  schemaVersion: number2().int().nonnegative(),
+  boots: number2().int().nonnegative(),
+  firstBootAt: timestamp,
+  startedAt: timestamp
+});
+var legionGoAdmission = strictObject({
+  cap: number2().int().nonnegative(),
+  active: array(nonEmptyString2),
+  waiting: array(nonEmptyString2)
+});
+var LegionGoStateResponse = strictObject({
+  daemon: goDaemonInfo,
+  admission: legionGoAdmission,
+  issues: record(string2(), legionGoIssue)
+});
+var LegionGoRegisterResponse = strictObject({
+  claimToken: nonEmptyString2,
+  tree: nonEmptyString2,
+  issue: nonEmptyString2,
+  role: _enum2(LEGION_ROLES),
+  generation: number2().int().positive(),
+  secret: nonEmptyString2
+});
+var LegionGoErrorResponse = strictObject({
+  error: nonEmptyString2
+});
+var legionGoDeliveryView = strictObject({
+  id: nonEmptyString2,
+  task: nonEmptyString2,
+  queuedAt: timestamp,
+  deliveredAt: timestamp.optional(),
+  confirmedAt: timestamp.optional()
+});
+var LegionGoOperatorClaimResponse = strictObject({
+  token: nonEmptyString2,
+  tree: nonEmptyString2,
+  issue: nonEmptyString2,
+  role: _enum2(LEGION_ROLES),
+  generation: number2().int().nonnegative(),
+  state: _enum2(LEGION_GO_CLAIM_STATES),
+  session: string2(),
+  sessionFile: string2(),
+  locator: legionGoLocator.optional(),
+  budgets: strictObject({
+    launchFailures: number2().int().nonnegative(),
+    promptFailures: number2().int().nonnegative(),
+    promptRetires: number2().int().nonnegative()
+  }),
+  uncertainStreak: number2().int().nonnegative(),
+  pending: legionGoDeliveryView.optional()
+});
+var LegionGoOperatorClaimsResponse = strictObject({
+  claims: array(LegionGoOperatorClaimResponse)
+});
+
+// src/legion/go-daemon-client.ts
+class LegionGoDaemonApiError extends Error {
+  method;
+  path;
+  status;
+  detail;
+  constructor(method, path, status, detail) {
+    super(`${method} ${path} failed with ${status}: ${detail}`);
+    this.method = method;
+    this.path = path;
+    this.status = status;
+    this.detail = detail;
+    this.name = "LegionGoDaemonApiError";
+  }
+}
+
+class LegionGoDaemonContractError extends Error {
+  method;
+  path;
+  status;
+  constructor(method, path, status, problem) {
+    super(`${method} ${path} answered ${status} with a body the Go daemon API contract does not describe: ${problem}`);
+    this.method = method;
+    this.path = path;
+    this.status = status;
+    this.name = "LegionGoDaemonContractError";
+  }
+}
+function parseStrictly(schema, body) {
+  let json;
+  try {
+    json = JSON.parse(body);
+  } catch (error) {
+    return { problem: `not JSON (${messageFor(error)})` };
+  }
+  const parsed = schema.safeParse(json);
+  if (parsed.success)
+    return { value: parsed.data };
+  return {
+    problem: parsed.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ")
+  };
+}
+function createLegionGoDaemonClient(baseUrl, fetchFn = fetch) {
+  const endpoint = baseUrl.replace(/\/+$/, "");
+  const call = async (method, path, body) => {
+    const response = await fetchFn(`${endpoint}${path}`, body === undefined ? undefined : {
+      method,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    const text = await response.text();
+    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})`);
+  };
+  const read = async (method, path, schema, body) => {
+    const { status, text } = await call(method, path, body);
+    const parsed = parseStrictly(schema, text);
+    if ("problem" in parsed) {
+      throw new LegionGoDaemonContractError(method, path, status, parsed.problem);
+    }
+    return parsed.value;
+  };
+  const acknowledge = async (path, body) => {
+    const { status, text } = await call("POST", path, body);
+    if (status !== 204 || text !== "") {
+      throw new LegionGoDaemonContractError("POST", path, status, "the route answers 204 with no body");
+    }
+  };
+  return {
+    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)
+  };
+}
+
 // src/legion/jj-attribution.ts
 import { execFile } from "child_process";
 import { mkdir, rename as rename2, writeFile as writeFile2 } from "fs/promises";
@@ -30546,6 +31515,114 @@ commit_trailers = '"Omp-Session: ${id}"'
   }
 }
 
+// src/legion/go-bootstrap.ts
+var READY_RETRY_ATTEMPTS = 3;
+var READY_RETRY_DELAY_MS = 1000;
+function isNetworkOrTimeoutError(error) {
+  if (!(error instanceof Error))
+    return false;
+  if (error.name === "NetworkError" || error.name === "TimeoutError")
+    return true;
+  const code = "code" in error && typeof error.code === "string" ? error.code : undefined;
+  return code === "ConnectionRefused" || code === "ConnectionTimeout" || code === "EAI_AGAIN" || code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EHOSTUNREACH" || code === "ENETUNREACH" || code === "ENOTFOUND" || code === "ETIMEDOUT" || error instanceof TypeError && (error.message === "Failed to fetch" || error.message === "fetch failed");
+}
+function exitOnGoRegistrationRefusal(error, exitProcess) {
+  if (error instanceof LegionGoDaemonApiError) {
+    console.error(`[legion] claims/register registration failed (${error.status}): ${error.detail}`);
+    if (error.status >= 400 && error.status < 500)
+      exitProcess(1);
+  }
+  throw error;
+}
+async function callGoReadyWithRetry(label, call) {
+  for (let attempt = 1;; attempt++) {
+    try {
+      await call();
+      return;
+    } catch (error) {
+      const retryable = error instanceof LegionGoDaemonApiError ? error.status >= 500 && error.status < 600 : isNetworkOrTimeoutError(error);
+      if (!retryable)
+        throw error;
+      if (attempt === READY_RETRY_ATTEMPTS) {
+        console.error(`[legion] ${label} failed after ${attempt} attempts: ${messageFor(error)}`);
+        throw error;
+      }
+      console.error(`[legion] ${label} failed (attempt ${attempt}/${READY_RETRY_ATTEMPTS}), retrying: ${messageFor(error)}`);
+      const retryDelay = Promise.withResolvers();
+      setTimeout(retryDelay.resolve, READY_RETRY_DELAY_MS);
+      await retryDelay.promise;
+    }
+  }
+}
+async function bootstrapGoClaim(context, state) {
+  const classification = classifySession(process.env);
+  if (classification.kind === "not-legion")
+    return;
+  if (classification.kind === "controller") {
+    throw new Error("LEGION_DAEMON_API=go names the Go daemon, which launches no controller session");
+  }
+  const sessionID = context.sessionManager.getSessionId();
+  const capability = state.capability();
+  if (capability !== undefined && capability.sessionID !== sessionID)
+    return;
+  const existing = state.bootstrap();
+  if (existing !== undefined)
+    return existing;
+  const bootToken = requiredSecret(process.env, "LEGION_BOOT_TOKEN");
+  const daemon = createLegionGoDaemonClient(requiredEnvironment(process.env, "LEGION_DAEMON_URL"));
+  const bootstrap = (async () => {
+    const { sessionFile, agentId } = await state.persistedTranscript(context);
+    state.recordBootstrappedSession(sessionFile);
+    const claim = await daemon.register({
+      bootToken,
+      sessionId: sessionID,
+      ompSessionFile: sessionFile,
+      agentId,
+      pluginContract: package_default.legion.goDaemonApiVersion
+    }).catch((error) => exitOnGoRegistrationRefusal(error, state.exitProcess));
+    const ready = {
+      claimToken: claim.claimToken,
+      sessionId: sessionID,
+      secret: claim.secret,
+      generation: claim.generation
+    };
+    try {
+      await exportJjSessionAttribution(sessionFile, requiredEnvironment(process.env, "LEGION_STATE_DIR"));
+      state.setCapability({
+        kind: "phase-worker",
+        sessionID,
+        tree: claim.tree,
+        issue: claim.issue,
+        role: claim.role,
+        roleToken: claim.claimToken,
+        secret: claim.secret
+      });
+      await claimEnvoyRole(sessionID, claim.claimToken, context);
+      await callGoReadyWithRetry("claims/ready", () => daemon.ready(ready));
+      onEnvoyRoleRegained(async (role, reason) => {
+        if (role !== claim.claimToken)
+          return;
+        try {
+          await callGoReadyWithRetry("claims/ready after role regain", () => daemon.ready(ready));
+          console.error(`[legion] re-ran claims/ready after role ${role} was ${reason}`);
+        } catch (error) {
+          console.error(`[legion] claims/ready after role ${role} was ${reason} failed; the daemon's queued task stays undelivered until the next regain or boot: ${messageFor(error)}`);
+        }
+      });
+    } catch (error) {
+      console.error(`[legion] Go claim boot failed after claims/register registered ${claim.claimToken}; exiting so the daemon launches it again: ${messageFor(error)}`);
+      state.exitProcess(1);
+    }
+  })();
+  state.setBootstrap(bootstrap);
+  try {
+    await bootstrap;
+  } catch (error) {
+    state.setBootstrap(undefined);
+    throw error;
+  }
+}
+
 // src/legion/tools.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
@@ -30748,9 +31825,9 @@ function exitOnRegistrationRefusal(route, error) {
   }
   throw error;
 }
-var READY_RETRY_ATTEMPTS = 3;
-var READY_RETRY_DELAY_MS = 1000;
-function isNetworkOrTimeoutError(error) {
+var READY_RETRY_ATTEMPTS2 = 3;
+var READY_RETRY_DELAY_MS2 = 1000;
+function isNetworkOrTimeoutError2(error) {
   if (!(error instanceof Error))
     return false;
   if (error.name === "NetworkError" || error.name === "TimeoutError")
@@ -30759,21 +31836,21 @@ function isNetworkOrTimeoutError(error) {
   return code === "ConnectionRefused" || code === "ConnectionTimeout" || code === "EAI_AGAIN" || code === "ECONNREFUSED" || code === "ECONNRESET" || code === "EHOSTUNREACH" || code === "ENETUNREACH" || code === "ENOTFOUND" || code === "ETIMEDOUT" || error instanceof TypeError && (error.message === "Failed to fetch" || error.message === "fetch failed");
 }
 var callReadyWithRetry = async (label, call) => {
-  for (let attempt = 1;attempt <= READY_RETRY_ATTEMPTS; attempt++) {
+  for (let attempt = 1;attempt <= READY_RETRY_ATTEMPTS2; attempt++) {
     try {
       await call();
       return;
     } catch (error) {
-      const retryable = error instanceof LegionDaemonApiError ? error.status >= 500 && error.status < 600 : isNetworkOrTimeoutError(error);
+      const retryable = error instanceof LegionDaemonApiError ? error.status >= 500 && error.status < 600 : isNetworkOrTimeoutError2(error);
       if (!retryable)
         throw error;
-      if (attempt === READY_RETRY_ATTEMPTS) {
+      if (attempt === READY_RETRY_ATTEMPTS2) {
         console.error(`[legion] ${label} failed after ${attempt} attempts: ${messageFor(error)}`);
         throw error;
       }
-      console.error(`[legion] ${label} failed (attempt ${attempt}/${READY_RETRY_ATTEMPTS}), retrying: ${messageFor(error)}`);
+      console.error(`[legion] ${label} failed (attempt ${attempt}/${READY_RETRY_ATTEMPTS2}), retrying: ${messageFor(error)}`);
       const retryDelay = Promise.withResolvers();
-      setTimeout(retryDelay.resolve, READY_RETRY_DELAY_MS);
+      setTimeout(retryDelay.resolve, READY_RETRY_DELAY_MS2);
       await retryDelay.promise;
     }
   }
@@ -31185,6 +32262,21 @@ function legionExtension(pi) {
   pi.on("session_start", async (_event, context) => {
     if (await checkSubagentSession(context))
       return;
+    if (process.env.LEGION_DAEMON_API === "go") {
+      return bootstrapGoClaim(context, {
+        capability: () => capability,
+        setCapability: (next) => {
+          capability = next;
+        },
+        bootstrap: () => bootstrap,
+        setBootstrap: (next) => {
+          bootstrap = next;
+        },
+        exitProcess,
+        persistedTranscript,
+        recordBootstrappedSession
+      });
+    }
     const classification = classifySession(process.env);
     switch (classification.kind) {
       case "controller":

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

@@ -265,8 +265,8 @@ later phase keeps it current rather than replacing it:
 resolved <thread URL>
 left open <thread URL> — newest reply by <login> is not an acceptance
 
-**Thermo:** thermonuclear-deep-review + thermonuclear-code-quality run once at <head-sha>:
-<verdict>. (omitted entirely on a docs-only PR — no thermo pass runs)
+**Thermo:** `ce-simplify-code` once at <head-sha>: <0 applied | applied → new head <sha>>; thermonuclear pair at the final head <sha>:
+<verdict>. (omitted entirely on a docs-only PR — there is no code for either pass, so neither runs)
 
 **E2E (implementer):** <surface> — ran `<command or run id>`, observed <result>, at head <sha>.
 Negative control: <deliberately broken input> → <refusal or failure observed>.
@@ -367,9 +367,22 @@ this proof.
   `E2E` line's head to the new SHA with
   `rebase re-check <old-sha> → <new-sha>: fingerprint unchanged, bare gates only`; the
   real-surface verification is not repeated. Different: a full test round.
+- **The implementer runs `ce-simplify-code` once per pull request, after the last review round
+  closes and before the reviewer's final pass, when the diff touches runtime code; a docs-only
+  diff gets none.** It is scoped to the pull request's own diff, at the head where the last review
+  round closed: nothing applied leaves that head final; applied → the applied head is the final
+  head: CI runs on it, the pair runs once on it, and the E2E proof re-runs on it for the surface
+  the simplify diff touched (Sami, 2026-09-13: test on the real surface before merging, no
+  shortcuts — a refactor that "preserves behaviour" is a claim until it is executed). That cost is
+  why 0-applied is the expected outcome and a pass that applies is spent sparingly. At the applied
+  head the implementer re-cites the `CI` line and re-runs its own proof into `E2E (implementer)`,
+  and the tester re-runs its proof for the touched surface into `E2E (tester)`, before the
+  reviewer's final pass. Simplify is the last code change; the pair is the last review. Record it
+  in the `Thermo` line.
 - The reviewer verifies the `CI`, `Threads`, and `E2E` facts against GitHub directly —
   never from a handoff — then runs `task(agent="thermonuclear-deep-review")` and
-  `task(agent="thermonuclear-code-quality")` once at that head and records the verdict.
+  `task(agent="thermonuclear-code-quality")` once at that head — the head the implementer's
+  simplify pass left final — and records the verdict.
   Approval is refused while either `E2E (implementer)` or `E2E (tester)` is missing: `REQUEST_CHANGES` naming the missing line.
   Skip the `Thermo` line entirely on a docs-only PR. Submit **one review per round** —
   `REQUEST_CHANGES` when any correctness finding stands, otherwise `COMMENT` while the head

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion-envoy",
-  "version": "1.59.1",
+  "version": "1.60.1",
   "type": "module",
   "omp": {
     "extensions": [
@@ -12,7 +12,8 @@
     ]
   },
   "legion": {
-    "daemonApiVersion": 8
+    "daemonApiVersion": 8,
+    "goDaemonApiVersion": 1
   },
   "repository": {
     "type": "git",