@paigy/mcp 0.34.0 → 0.36.0

package/dist/{chunk-X42EUXML.js → chunk-PRC6GKRN.js}

@@ -1,9 +1,13 @@
 // ../../packages/sdk/dist/index.js
 import { createRequire as __sdkCreateRequire } from "module";
 import { randomUUID } from "crypto";
+import { z as z2 } from "zod";
 import { z } from "zod";
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind3 } from "zod/v3";
+import { ZodFirstPartyTypeKind } from "zod/v3";
+import { ZodFirstPartyTypeKind as ZodFirstPartyTypeKind2 } from "zod/v3";
+import { createHash } from "crypto";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
 import { homedir } from "os";
 import { join } from "path";
 var require2 = __sdkCreateRequire(import.meta.url);
@@ -336,17 +340,17 @@ var require_nacl_fast = __commonJS({
       }
       var sigma = new Uint8Array([101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107]);
       function crypto_stream_salsa20_xor(c, cpos, m, mpos, b, n, k) {
-        var z2 = new Uint8Array(16), x = new Uint8Array(64);
+        var z3 = new Uint8Array(16), x = new Uint8Array(64);
         var u, i;
-        for (i = 0; i < 16; i++) z2[i] = 0;
-        for (i = 0; i < 8; i++) z2[i] = n[i];
+        for (i = 0; i < 16; i++) z3[i] = 0;
+        for (i = 0; i < 8; i++) z3[i] = n[i];
         while (b >= 64) {
-          crypto_core_salsa20(x, z2, k, sigma);
+          crypto_core_salsa20(x, z3, k, sigma);
           for (i = 0; i < 64; i++) c[cpos + i] = m[mpos + i] ^ x[i];
           u = 1;
           for (i = 8; i < 16; i++) {
-            u = u + (z2[i] & 255) | 0;
-            z2[i] = u & 255;
+            u = u + (z3[i] & 255) | 0;
+            z3[i] = u & 255;
             u >>>= 8;
           }
           b -= 64;
@@ -354,30 +358,30 @@ var require_nacl_fast = __commonJS({
           mpos += 64;
         }
         if (b > 0) {
-          crypto_core_salsa20(x, z2, k, sigma);
+          crypto_core_salsa20(x, z3, k, sigma);
           for (i = 0; i < b; i++) c[cpos + i] = m[mpos + i] ^ x[i];
         }
         return 0;
       }
       function crypto_stream_salsa20(c, cpos, b, n, k) {
-        var z2 = new Uint8Array(16), x = new Uint8Array(64);
+        var z3 = new Uint8Array(16), x = new Uint8Array(64);
         var u, i;
-        for (i = 0; i < 16; i++) z2[i] = 0;
-        for (i = 0; i < 8; i++) z2[i] = n[i];
+        for (i = 0; i < 16; i++) z3[i] = 0;
+        for (i = 0; i < 8; i++) z3[i] = n[i];
         while (b >= 64) {
-          crypto_core_salsa20(x, z2, k, sigma);
+          crypto_core_salsa20(x, z3, k, sigma);
           for (i = 0; i < 64; i++) c[cpos + i] = x[i];
           u = 1;
           for (i = 8; i < 16; i++) {
-            u = u + (z2[i] & 255) | 0;
-            z2[i] = u & 255;
+            u = u + (z3[i] & 255) | 0;
+            z3[i] = u & 255;
             u >>>= 8;
           }
           b -= 64;
           cpos += 64;
         }
         if (b > 0) {
-          crypto_core_salsa20(x, z2, k, sigma);
+          crypto_core_salsa20(x, z3, k, sigma);
           for (i = 0; i < b; i++) c[cpos + i] = x[i];
         }
         return 0;
@@ -1257,12 +1261,12 @@ var require_nacl_fast = __commonJS({
         for (a = 0; a < 16; a++) o[a] = c[a];
       }
       function crypto_scalarmult(q, n, p) {
-        var z2 = new Uint8Array(32);
+        var z3 = new Uint8Array(32);
         var x = new Float64Array(80), r, i;
         var a = gf(), b = gf(), c = gf(), d = gf(), e = gf(), f = gf();
-        for (i = 0; i < 31; i++) z2[i] = n[i];
-        z2[31] = n[31] & 127 | 64;
-        z2[0] &= 248;
+        for (i = 0; i < 31; i++) z3[i] = n[i];
+        z3[31] = n[31] & 127 | 64;
+        z3[0] &= 248;
         unpack25519(x, p);
         for (i = 0; i < 16; i++) {
           b[i] = x[i];
@@ -1270,7 +1274,7 @@ var require_nacl_fast = __commonJS({
         }
         a[0] = d[0] = 1;
         for (i = 254; i >= 0; --i) {
-          r = z2[i >>> 3] >>> (i & 7) & 1;
+          r = z3[i >>> 3] >>> (i & 7) & 1;
           sel25519(a, b, r);
           sel25519(c, d, r);
           A(e, a, c);
@@ -2271,6 +2275,12 @@ async function proxy() {
 }
 var INSTANCE_ID = randomUUID();
 var SESSION_ID = process.env.PAIGY_SESSION_ID ?? process.env.CLAUDE_CODE_SESSION_ID ?? INSTANCE_ID;
+function sessionId() {
+  return SESSION_ID;
+}
+function isNetworkError(e) {
+  return e instanceof Error && e.message.startsWith(NETWORK_MSG);
+}
 async function reach(url, init) {
   try {
     const headers = {
@@ -2283,73 +2293,1300 @@ async function reach(url, init) {
     throw new Error(`${NETWORK_MSG} (${e?.message ?? String(e)})`);
   }
 }
-var TITLE_MAX = 90;
-var CHUNKS_MAX = 8;
-var CHUNK_MAX = 300;
-var ASK_MAX = 1e4;
-var OPTION_MAX = 80;
-var NEEDS_MAX = 6;
-var UNSPEAKABLE = /```/;
-function normalizeSpeech(req) {
-  const flat = (s) => s.replace(/\s+/g, " ").trim();
+var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+var getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i])
+      break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+var parseCatchDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+function parseDateDef(def, refs, overrideDateStrategy) {
+  const strategy = overrideDateStrategy ?? refs.dateStrategy;
+  if (Array.isArray(strategy)) {
+    return {
+      anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))
+    };
+  }
+  switch (strategy) {
+    case "string":
+    case "format:date-time":
+      return {
+        type: "string",
+        format: "date-time"
+      };
+    case "format:date":
+      return {
+        type: "string",
+        format: "date"
+      };
+    case "integer":
+      return integerDateParser(def, refs);
+  }
+}
+var integerDateParser = (def, refs) => {
+  const res = {
+    type: "integer",
+    format: "unix-time"
+  };
+  if (refs.target === "openApi3") {
+    return res;
+  }
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "min":
+        setResponseValueAndErrors(
+          res,
+          "minimum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+      case "max":
+        setResponseValueAndErrors(
+          res,
+          "maximum",
+          check.value,
+          // This is in milliseconds
+          check.message,
+          refs
+        );
+        break;
+    }
+  }
+  return res;
+};
+function parseDefaultDef(_def, refs) {
+  return {
+    ...parseDef(_def.innerType._def, refs),
+    default: _def.defaultValue()
+  };
+}
+function parseEffectsDef(_def, refs) {
+  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : parseAnyDef(refs);
+}
+function parseEnumDef(def) {
+  return {
+    type: "string",
+    enum: Array.from(def.values)
+  };
+}
+var isJsonSchema7AllOfType = (type) => {
+  if ("type" in type && type.type === "string")
+    return false;
+  return "allOf" in type;
+};
+function parseIntersectionDef(def, refs) {
+  const allOf = [
+    parseDef(def.left._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "0"]
+    }),
+    parseDef(def.right._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "allOf", "1"]
+    })
+  ].filter((x) => !!x);
+  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
+  const mergedAllOf = [];
+  allOf.forEach((schema) => {
+    if (isJsonSchema7AllOfType(schema)) {
+      mergedAllOf.push(...schema.allOf);
+      if (schema.unevaluatedProperties === void 0) {
+        unevaluatedProperties = void 0;
+      }
+    } else {
+      let nestedSchema = schema;
+      if ("additionalProperties" in schema && schema.additionalProperties === false) {
+        const { additionalProperties, ...rest } = schema;
+        nestedSchema = rest;
+      } else {
+        unevaluatedProperties = void 0;
+      }
+      mergedAllOf.push(nestedSchema);
+    }
+  });
+  return mergedAllOf.length ? {
+    allOf: mergedAllOf,
+    ...unevaluatedProperties
+  } : void 0;
+}
+function parseLiteralDef(def, refs) {
+  const parsedType = typeof def.value;
+  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+    return {
+      type: Array.isArray(def.value) ? "array" : "object"
+    };
+  }
+  if (refs.target === "openApi3") {
+    return {
+      type: parsedType === "bigint" ? "integer" : parsedType,
+      enum: [def.value]
+    };
+  }
+  return {
+    type: parsedType === "bigint" ? "integer" : parsedType,
+    const: def.value
+  };
+}
+var emojiRegex = void 0;
+var zodPatterns = {
+  /**
+   * `c` was changed to `[cC]` to replicate /i flag
+   */
+  cuid: /^[cC][^\s-]{8,}$/,
+  cuid2: /^[0-9a-z]+$/,
+  ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+  /**
+   * `a-z` was added to replicate /i flag
+   */
+  email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+  /**
+   * Constructed a valid Unicode RegExp
+   *
+   * Lazily instantiate since this type of regex isn't supported
+   * in all envs (e.g. React Native).
+   *
+   * See:
+   * https://github.com/colinhacks/zod/issues/2433
+   * Fix in Zod:
+   * https://github.com/colinhacks/zod/commit/9340fd51e48576a75adc919bff65dbc4a5d4c99b
+   */
+  emoji: () => {
+    if (emojiRegex === void 0) {
+      emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+    }
+    return emojiRegex;
+  },
+  /**
+   * Unused
+   */
+  uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+  /**
+   * Unused
+   */
+  ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+  ipv4Cidr: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/,
+  /**
+   * Unused
+   */
+  ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+  ipv6Cidr: /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
+  base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+  base64url: /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/,
+  nanoid: /^[a-zA-Z0-9_-]{21}$/,
+  jwt: /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/
+};
+function parseStringDef(def, refs) {
+  const res = {
+    type: "string"
+  };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          break;
+        case "max":
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "email":
+          switch (refs.emailStrategy) {
+            case "format:email":
+              addFormat(res, "email", check.message, refs);
+              break;
+            case "format:idn-email":
+              addFormat(res, "idn-email", check.message, refs);
+              break;
+            case "pattern:zod":
+              addPattern(res, zodPatterns.email, check.message, refs);
+              break;
+          }
+          break;
+        case "url":
+          addFormat(res, "uri", check.message, refs);
+          break;
+        case "uuid":
+          addFormat(res, "uuid", check.message, refs);
+          break;
+        case "regex":
+          addPattern(res, check.regex, check.message, refs);
+          break;
+        case "cuid":
+          addPattern(res, zodPatterns.cuid, check.message, refs);
+          break;
+        case "cuid2":
+          addPattern(res, zodPatterns.cuid2, check.message, refs);
+          break;
+        case "startsWith":
+          addPattern(res, RegExp(`^${escapeLiteralCheckValue(check.value, refs)}`), check.message, refs);
+          break;
+        case "endsWith":
+          addPattern(res, RegExp(`${escapeLiteralCheckValue(check.value, refs)}$`), check.message, refs);
+          break;
+        case "datetime":
+          addFormat(res, "date-time", check.message, refs);
+          break;
+        case "date":
+          addFormat(res, "date", check.message, refs);
+          break;
+        case "time":
+          addFormat(res, "time", check.message, refs);
+          break;
+        case "duration":
+          addFormat(res, "duration", check.message, refs);
+          break;
+        case "length":
+          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+          break;
+        case "includes": {
+          addPattern(res, RegExp(escapeLiteralCheckValue(check.value, refs)), check.message, refs);
+          break;
+        }
+        case "ip": {
+          if (check.version !== "v6") {
+            addFormat(res, "ipv4", check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addFormat(res, "ipv6", check.message, refs);
+          }
+          break;
+        }
+        case "base64url":
+          addPattern(res, zodPatterns.base64url, check.message, refs);
+          break;
+        case "jwt":
+          addPattern(res, zodPatterns.jwt, check.message, refs);
+          break;
+        case "cidr": {
+          if (check.version !== "v6") {
+            addPattern(res, zodPatterns.ipv4Cidr, check.message, refs);
+          }
+          if (check.version !== "v4") {
+            addPattern(res, zodPatterns.ipv6Cidr, check.message, refs);
+          }
+          break;
+        }
+        case "emoji":
+          addPattern(res, zodPatterns.emoji(), check.message, refs);
+          break;
+        case "ulid": {
+          addPattern(res, zodPatterns.ulid, check.message, refs);
+          break;
+        }
+        case "base64": {
+          switch (refs.base64Strategy) {
+            case "format:binary": {
+              addFormat(res, "binary", check.message, refs);
+              break;
+            }
+            case "contentEncoding:base64": {
+              setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+              break;
+            }
+            case "pattern:zod": {
+              addPattern(res, zodPatterns.base64, check.message, refs);
+              break;
+            }
+          }
+          break;
+        }
+        case "nanoid": {
+          addPattern(res, zodPatterns.nanoid, check.message, refs);
+        }
+        case "toLowerCase":
+        case "toUpperCase":
+        case "trim":
+          break;
+        default:
+          /* @__PURE__ */ ((_) => {
+          })(check);
+      }
+    }
+  }
+  return res;
+}
+function escapeLiteralCheckValue(literal, refs) {
+  return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(literal) : literal;
+}
+var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+function escapeNonAlphaNumeric(source) {
+  let result = "";
+  for (let i = 0; i < source.length; i++) {
+    if (!ALPHA_NUMERIC.has(source[i])) {
+      result += "\\";
+    }
+    result += source[i];
+  }
+  return result;
+}
+function addFormat(schema, value, message, refs) {
+  if (schema.format || schema.anyOf?.some((x) => x.format)) {
+    if (!schema.anyOf) {
+      schema.anyOf = [];
+    }
+    if (schema.format) {
+      schema.anyOf.push({
+        format: schema.format,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { format: schema.errorMessage.format }
+        }
+      });
+      delete schema.format;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.format;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.anyOf.push({
+      format: value,
+      ...message && refs.errorMessages && { errorMessage: { format: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "format", value, message, refs);
+  }
+}
+function addPattern(schema, regex, message, refs) {
+  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
+    if (!schema.allOf) {
+      schema.allOf = [];
+    }
+    if (schema.pattern) {
+      schema.allOf.push({
+        pattern: schema.pattern,
+        ...schema.errorMessage && refs.errorMessages && {
+          errorMessage: { pattern: schema.errorMessage.pattern }
+        }
+      });
+      delete schema.pattern;
+      if (schema.errorMessage) {
+        delete schema.errorMessage.pattern;
+        if (Object.keys(schema.errorMessage).length === 0) {
+          delete schema.errorMessage;
+        }
+      }
+    }
+    schema.allOf.push({
+      pattern: stringifyRegExpWithFlags(regex, refs),
+      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
+    });
+  } else {
+    setResponseValueAndErrors(schema, "pattern", stringifyRegExpWithFlags(regex, refs), message, refs);
+  }
+}
+function stringifyRegExpWithFlags(regex, refs) {
+  if (!refs.applyRegexFlags || !regex.flags) {
+    return regex.source;
+  }
+  const flags = {
+    i: regex.flags.includes("i"),
+    m: regex.flags.includes("m"),
+    s: regex.flags.includes("s")
+    // `.` matches newlines
+  };
+  const source = flags.i ? regex.source.toLowerCase() : regex.source;
+  let pattern = "";
+  let isEscaped = false;
+  let inCharGroup = false;
+  let inCharRange = false;
+  for (let i = 0; i < source.length; i++) {
+    if (isEscaped) {
+      pattern += source[i];
+      isEscaped = false;
+      continue;
+    }
+    if (flags.i) {
+      if (inCharGroup) {
+        if (source[i].match(/[a-z]/)) {
+          if (inCharRange) {
+            pattern += source[i];
+            pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+            inCharRange = false;
+          } else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+            pattern += source[i];
+            inCharRange = true;
+          } else {
+            pattern += `${source[i]}${source[i].toUpperCase()}`;
+          }
+          continue;
+        }
+      } else if (source[i].match(/[a-z]/)) {
+        pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+        continue;
+      }
+    }
+    if (flags.m) {
+      if (source[i] === "^") {
+        pattern += `(^|(?<=[\r
+]))`;
+        continue;
+      } else if (source[i] === "$") {
+        pattern += `($|(?=[\r
+]))`;
+        continue;
+      }
+    }
+    if (flags.s && source[i] === ".") {
+      pattern += inCharGroup ? `${source[i]}\r
+` : `[${source[i]}\r
+]`;
+      continue;
+    }
+    pattern += source[i];
+    if (source[i] === "\\") {
+      isEscaped = true;
+    } else if (inCharGroup && source[i] === "]") {
+      inCharGroup = false;
+    } else if (!inCharGroup && source[i] === "[") {
+      inCharGroup = true;
+    }
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+    return regex.source;
+  }
+  return pattern;
+}
+function parseRecordDef(def, refs) {
+  if (refs.target === "openAi") {
+    console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
+  }
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) {
+    return {
+      type: "object",
+      required: def.keyType._def.values,
+      properties: def.keyType._def.values.reduce((acc, key) => ({
+        ...acc,
+        [key]: parseDef(def.valueType._def, {
+          ...refs,
+          currentPath: [...refs.currentPath, "properties", key]
+        }) ?? parseAnyDef(refs)
+      }), {}),
+      additionalProperties: refs.rejectedAdditionalProperties
+    };
+  }
+  const schema = {
+    type: "object",
+    additionalProperties: parseDef(def.valueType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    }) ?? refs.allowedAdditionalProperties
+  };
+  if (refs.target === "openApi3") {
+    return schema;
+  }
+  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.checks?.length) {
+    const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodEnum) {
+    return {
+      ...schema,
+      propertyNames: {
+        enum: def.keyType._def.values
+      }
+    };
+  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind2.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind2.ZodString && def.keyType._def.type._def.checks?.length) {
+    const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
+    return {
+      ...schema,
+      propertyNames: keyType
+    };
+  }
+  return schema;
+}
+function parseMapDef(def, refs) {
+  if (refs.mapStrategy === "record") {
+    return parseRecordDef(def, refs);
+  }
+  const keys = parseDef(def.keyType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "0"]
+  }) || parseAnyDef(refs);
+  const values = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items", "items", "1"]
+  }) || parseAnyDef(refs);
+  return {
+    type: "array",
+    maxItems: 125,
+    items: {
+      type: "array",
+      items: [keys, values],
+      minItems: 2,
+      maxItems: 2
+    }
+  };
+}
+function parseNativeEnumDef(def) {
+  const object = def.values;
+  const actualKeys = Object.keys(def.values).filter((key) => {
+    return typeof object[object[key]] !== "number";
+  });
+  const actualValues = actualKeys.map((key) => object[key]);
+  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
   return {
-    ...req,
-    ...req.ask !== void 0 ? { ask: flat(req.ask) } : {},
-    ...req.context ? {
-      context: {
-        ...req.context,
-        title: flat(req.context.title),
-        description: req.context.description.map(flat)
+    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+    enum: actualValues
+  };
+}
+function parseNeverDef(refs) {
+  return refs.target === "openAi" ? void 0 : {
+    not: parseAnyDef({
+      ...refs,
+      currentPath: [...refs.currentPath, "not"]
+    })
+  };
+}
+function parseNullDef(refs) {
+  return refs.target === "openApi3" ? {
+    enum: ["null"],
+    nullable: true
+  } : {
+    type: "null"
+  };
+}
+var primitiveMappings = {
+  ZodString: "string",
+  ZodNumber: "number",
+  ZodBigInt: "integer",
+  ZodBoolean: "boolean",
+  ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+  if (refs.target === "openApi3")
+    return asAnyOf(def, refs);
+  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+    const types = options.reduce((types2, x) => {
+      const type = primitiveMappings[x._def.typeName];
+      return type && !types2.includes(type) ? [...types2, type] : types2;
+    }, []);
+    return {
+      type: types.length > 1 ? types : types[0]
+    };
+  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+    const types = options.reduce((acc, x) => {
+      const type = typeof x._def.value;
+      switch (type) {
+        case "string":
+        case "number":
+        case "boolean":
+          return [...acc, type];
+        case "bigint":
+          return [...acc, "integer"];
+        case "object":
+          if (x._def.value === null)
+            return [...acc, "null"];
+        case "symbol":
+        case "undefined":
+        case "function":
+        default:
+          return acc;
+      }
+    }, []);
+    if (types.length === options.length) {
+      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+      return {
+        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+        enum: options.reduce((acc, x) => {
+          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+        }, [])
+      };
+    }
+  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
+    return {
+      type: "string",
+      enum: options.reduce((acc, x) => [
+        ...acc,
+        ...x._def.values.filter((x2) => !acc.includes(x2))
+      ], [])
+    };
+  }
+  return asAnyOf(def, refs);
+}
+var asAnyOf = (def, refs) => {
+  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", `${i}`]
+  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
+  return anyOf.length ? { anyOf } : void 0;
+};
+function parseNullableDef(def, refs) {
+  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
+    if (refs.target === "openApi3") {
+      return {
+        type: primitiveMappings[def.innerType._def.typeName],
+        nullable: true
+      };
+    }
+    return {
+      type: [
+        primitiveMappings[def.innerType._def.typeName],
+        "null"
+      ]
+    };
+  }
+  if (refs.target === "openApi3") {
+    const base2 = parseDef(def.innerType._def, {
+      ...refs,
+      currentPath: [...refs.currentPath]
+    });
+    if (base2 && "$ref" in base2)
+      return { allOf: [base2], nullable: true };
+    return base2 && { ...base2, nullable: true };
+  }
+  const base = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "0"]
+  });
+  return base && { anyOf: [base, { type: "null" }] };
+}
+function parseNumberDef(def, refs) {
+  const res = {
+    type: "number"
+  };
+  if (!def.checks)
+    return res;
+  for (const check of def.checks) {
+    switch (check.kind) {
+      case "int":
+        res.type = "integer";
+        addErrorMessage(res, "type", check.message, refs);
+        break;
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+          }
+        } else {
+          if (!check.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+function parseObjectDef(def, refs) {
+  const forceOptionalIntoNullable = refs.target === "openAi";
+  const result = {
+    type: "object",
+    properties: {}
+  };
+  const required = [];
+  const shape = def.shape();
+  for (const propName in shape) {
+    let propDef = shape[propName];
+    if (propDef === void 0 || propDef._def === void 0) {
+      continue;
+    }
+    let propOptional = safeIsOptional(propDef);
+    if (propOptional && forceOptionalIntoNullable) {
+      if (propDef._def.typeName === "ZodOptional") {
+        propDef = propDef._def.innerType;
+      }
+      if (!propDef.isNullable()) {
+        propDef = propDef.nullable();
       }
-    } : {}
+      propOptional = false;
+    }
+    const parsedDef = parseDef(propDef._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "properties", propName],
+      propertyPath: [...refs.currentPath, "properties", propName]
+    });
+    if (parsedDef === void 0) {
+      continue;
+    }
+    result.properties[propName] = parsedDef;
+    if (!propOptional) {
+      required.push(propName);
+    }
+  }
+  if (required.length) {
+    result.required = required;
+  }
+  const additionalProperties = decideAdditionalProperties(def, refs);
+  if (additionalProperties !== void 0) {
+    result.additionalProperties = additionalProperties;
+  }
+  return result;
+}
+function decideAdditionalProperties(def, refs) {
+  if (def.catchall._def.typeName !== "ZodNever") {
+    return parseDef(def.catchall._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "additionalProperties"]
+    });
+  }
+  switch (def.unknownKeys) {
+    case "passthrough":
+      return refs.allowedAdditionalProperties;
+    case "strict":
+      return refs.rejectedAdditionalProperties;
+    case "strip":
+      return refs.removeAdditionalStrategy === "strict" ? refs.allowedAdditionalProperties : refs.rejectedAdditionalProperties;
+  }
+}
+function safeIsOptional(schema) {
+  try {
+    return schema.isOptional();
+  } catch {
+    return true;
+  }
+}
+var parseOptionalDef = (def, refs) => {
+  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+    return parseDef(def.innerType._def, refs);
+  }
+  const innerSchema = parseDef(def.innerType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "anyOf", "1"]
+  });
+  return innerSchema ? {
+    anyOf: [
+      {
+        not: parseAnyDef(refs)
+      },
+      innerSchema
+    ]
+  } : parseAnyDef(refs);
+};
+var parsePipelineDef = (def, refs) => {
+  if (refs.pipeStrategy === "input") {
+    return parseDef(def.in._def, refs);
+  } else if (refs.pipeStrategy === "output") {
+    return parseDef(def.out._def, refs);
+  }
+  const a = parseDef(def.in._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", "0"]
+  });
+  const b = parseDef(def.out._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+  });
+  return {
+    allOf: [a, b].filter((x) => x !== void 0)
+  };
+};
+function parsePromiseDef(def, refs) {
+  return parseDef(def.type._def, refs);
+}
+function parseSetDef(def, refs) {
+  const items = parseDef(def.valueType._def, {
+    ...refs,
+    currentPath: [...refs.currentPath, "items"]
+  });
+  const schema = {
+    type: "array",
+    uniqueItems: true,
+    items
+  };
+  if (def.minSize) {
+    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
+  }
+  if (def.maxSize) {
+    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+  }
+  return schema;
+}
+function parseTupleDef(def, refs) {
+  if (def.rest) {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
+      additionalItems: parseDef(def.rest._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "additionalItems"]
+      })
+    };
+  } else {
+    return {
+      type: "array",
+      minItems: def.items.length,
+      maxItems: def.items.length,
+      items: def.items.map((x, i) => parseDef(x._def, {
+        ...refs,
+        currentPath: [...refs.currentPath, "items", `${i}`]
+      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
+    };
+  }
+}
+function parseUndefinedDef(refs) {
+  return {
+    not: parseAnyDef(refs)
   };
 }
-function lintNotify(req) {
-  const problems = [];
-  if (req.ask !== void 0) {
-    if (req.ask.length > ASK_MAX)
-      problems.push(`ask is ${req.ask.length} chars \u2014 state the need and why it matters now in \u2264${ASK_MAX}; move detail into a smaller follow-up`);
-    if (UNSPEAKABLE.test(req.ask))
-      problems.push("ask contains a code fence \u2014 write it as plain prose (it may be read aloud on a call)");
-    for (const n of req.needs ?? []) {
-      if (n.length > OPTION_MAX) problems.push(`need "${n.slice(0, 40)}\u2026" is too long \u2014 each need is a short phrase (\u2264${OPTION_MAX} chars)`);
+function parseUnknownDef(refs) {
+  return parseAnyDef(refs);
+}
+var parseReadonlyDef = (def, refs) => {
+  return parseDef(def.innerType._def, refs);
+};
+var selectParser = (def, typeName, refs) => {
+  switch (typeName) {
+    case ZodFirstPartyTypeKind3.ZodString:
+      return parseStringDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodNumber:
+      return parseNumberDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodObject:
+      return parseObjectDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodBigInt:
+      return parseBigintDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodBoolean:
+      return parseBooleanDef();
+    case ZodFirstPartyTypeKind3.ZodDate:
+      return parseDateDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodUndefined:
+      return parseUndefinedDef(refs);
+    case ZodFirstPartyTypeKind3.ZodNull:
+      return parseNullDef(refs);
+    case ZodFirstPartyTypeKind3.ZodArray:
+      return parseArrayDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodUnion:
+    case ZodFirstPartyTypeKind3.ZodDiscriminatedUnion:
+      return parseUnionDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodIntersection:
+      return parseIntersectionDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodTuple:
+      return parseTupleDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodRecord:
+      return parseRecordDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodLiteral:
+      return parseLiteralDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodEnum:
+      return parseEnumDef(def);
+    case ZodFirstPartyTypeKind3.ZodNativeEnum:
+      return parseNativeEnumDef(def);
+    case ZodFirstPartyTypeKind3.ZodNullable:
+      return parseNullableDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodOptional:
+      return parseOptionalDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodMap:
+      return parseMapDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodSet:
+      return parseSetDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodLazy:
+      return () => def.getter()._def;
+    case ZodFirstPartyTypeKind3.ZodPromise:
+      return parsePromiseDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodNaN:
+    case ZodFirstPartyTypeKind3.ZodNever:
+      return parseNeverDef(refs);
+    case ZodFirstPartyTypeKind3.ZodEffects:
+      return parseEffectsDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodAny:
+      return parseAnyDef(refs);
+    case ZodFirstPartyTypeKind3.ZodUnknown:
+      return parseUnknownDef(refs);
+    case ZodFirstPartyTypeKind3.ZodDefault:
+      return parseDefaultDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodBranded:
+      return parseBrandedDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodReadonly:
+      return parseReadonlyDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodCatch:
+      return parseCatchDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodPipeline:
+      return parsePipelineDef(def, refs);
+    case ZodFirstPartyTypeKind3.ZodFunction:
+    case ZodFirstPartyTypeKind3.ZodVoid:
+    case ZodFirstPartyTypeKind3.ZodSymbol:
+      return void 0;
+    default:
+      return /* @__PURE__ */ ((_) => void 0)(typeName);
+  }
+};
+function parseDef(def, refs, forceResolution = false) {
+  const seenItem = refs.seen.get(def);
+  if (refs.override) {
+    const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+    if (overrideResult !== ignoreOverride) {
+      return overrideResult;
+    }
+  }
+  if (seenItem && !forceResolution) {
+    const seenSchema = get$ref(seenItem, refs);
+    if (seenSchema !== void 0) {
+      return seenSchema;
+    }
+  }
+  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
+  refs.seen.set(def, newItem);
+  const jsonSchemaOrGetter = selectParser(def, def.typeName, refs);
+  const jsonSchema = typeof jsonSchemaOrGetter === "function" ? parseDef(jsonSchemaOrGetter(), refs) : jsonSchemaOrGetter;
+  if (jsonSchema) {
+    addMeta(def, refs, jsonSchema);
+  }
+  if (refs.postProcess) {
+    const postProcessResult = refs.postProcess(jsonSchema, def, refs);
+    newItem.jsonSchema = jsonSchema;
+    return postProcessResult;
+  }
+  newItem.jsonSchema = jsonSchema;
+  return jsonSchema;
+}
+var get$ref = (item, refs) => {
+  switch (refs.$refStrategy) {
+    case "root":
+      return { $ref: item.path.join("/") };
+    case "relative":
+      return { $ref: getRelativePath(refs.currentPath, item.path) };
+    case "none":
+    case "seen": {
+      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+        return parseAnyDef(refs);
+      }
+      return refs.$refStrategy === "seen" ? parseAnyDef(refs) : void 0;
+    }
+  }
+};
+var addMeta = (def, refs, jsonSchema) => {
+  if (def.description) {
+    jsonSchema.description = def.description;
+    if (refs.markdownDescription) {
+      jsonSchema.markdownDescription = def.description;
+    }
+  }
+  return jsonSchema;
+};
+var zodToJsonSchema = (schema, options) => {
+  const refs = getRefs(options);
+  let definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
+    ...acc,
+    [name2]: parseDef(schema2._def, {
+      ...refs,
+      currentPath: [...refs.basePath, refs.definitionPath, name2]
+    }, true) ?? parseAnyDef(refs)
+  }), {}) : void 0;
+  const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
+  const main = parseDef(schema._def, name === void 0 ? refs : {
+    ...refs,
+    currentPath: [...refs.basePath, refs.definitionPath, name]
+  }, false) ?? parseAnyDef(refs);
+  const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
+  if (title !== void 0) {
+    main.title = title;
+  }
+  if (refs.flags.hasReferencedOpenAiAnyType) {
+    if (!definitions) {
+      definitions = {};
+    }
+    if (!definitions[refs.openAiAnyTypeName]) {
+      definitions[refs.openAiAnyTypeName] = {
+        // Skipping "object" as no properties can be defined and additionalProperties must be "false"
+        type: ["string", "number", "integer", "boolean", "array", "null"],
+        items: {
+          $ref: refs.$refStrategy === "relative" ? "1" : [
+            ...refs.basePath,
+            refs.definitionPath,
+            refs.openAiAnyTypeName
+          ].join("/")
+        }
+      };
     }
-    if ((req.needs?.length ?? 0) > NEEDS_MAX)
-      problems.push(`${req.needs?.length} needs \u2014 cap at ${NEEDS_MAX}; a call can't cover more in one conversation, split the rest into a second ask`);
-    return problems;
   }
-  const spoken = req.urgency === "call" || req.urgency === "banner";
-  if (req.context) {
-    if (req.context.title.length > TITLE_MAX)
-      problems.push(`title is ${req.context.title.length} chars \u2014 shorten to \u2264${TITLE_MAX} (it's what shows on the banner / gets spoken on a ring)`);
-    if (UNSPEAKABLE.test(req.context.title))
-      problems.push("title contains a code fence \u2014 one plain-prose line");
-    if (req.context.description.length > CHUNKS_MAX)
-      problems.push(`${req.context.description.length} description chunks \u2014 cap at ${CHUNKS_MAX}; merge or drop the rest`);
-    for (const [i, chunk] of req.context.description.entries()) {
-      if (chunk.length > CHUNK_MAX)
-        problems.push(`description[${i}] is ${chunk.length} chars \u2014 split it into standalone points of \u2264${CHUNK_MAX}`);
+  const combined = name === void 0 ? definitions ? {
+    ...main,
+    [refs.definitionPath]: definitions
+  } : main : {
+    $ref: [
+      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
+      refs.definitionPath,
+      name
+    ].join("/"),
+    [refs.definitionPath]: {
+      ...definitions,
+      [name]: main
     }
-    if (spoken && UNSPEAKABLE.test(req.context.description.join(" ")))
-      problems.push("urgency is 'call'/'banner' but the description has a code fence \u2014 rewrite in spoken register (it will be read aloud)");
+  };
+  if (refs.target === "jsonSchema7") {
+    combined.$schema = "http://json-schema.org/draft-07/schema#";
+  } else if (refs.target === "jsonSchema2019-09" || refs.target === "openAi") {
+    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+  }
+  if (refs.target === "openAi" && ("anyOf" in combined || "oneOf" in combined || "allOf" in combined || "type" in combined && Array.isArray(combined.type))) {
+    console.warn("Warning: OpenAI may not support schemas with unions as roots! Try wrapping it in an object property.");
   }
-  for (const o of req.options ?? []) {
-    if (o.label.length > OPTION_MAX)
-      problems.push(`option label "${o.label.slice(0, 40)}\u2026" is ${o.label.length} chars \u2014 labels must read at a glance (\u2264${OPTION_MAX}); move detail into the description`);
+  return combined;
+};
+var OPTIONS_MIN = 2;
+var OPTIONS_MAX = 6;
+var MISSED_CALL_PLAN = {
+  retry_10m: { kind: "every", minutes: 10 },
+  retry_30m: { kind: "every", minutes: 30 },
+  retry_60m: { kind: "every", minutes: 60 },
+  backoff_gentle: { kind: "at", minutes: [30, 120, 360] },
+  backoff_standard: { kind: "at", minutes: [10, 30, 120] },
+  backoff_aggressive: { kind: "at", minutes: [5, 15, 45] },
+  inbox: { kind: "once" },
+  dismiss: { kind: "grace", minutes: 2 }
+};
+function draft2020(node) {
+  if (Array.isArray(node)) return node.map(draft2020);
+  if (node && typeof node === "object") {
+    const o = node;
+    for (const [excl, lim] of [["exclusiveMinimum", "minimum"], ["exclusiveMaximum", "maximum"]]) {
+      if (typeof o[excl] === "boolean") {
+        if (o[excl] === true && typeof o[lim] === "number") {
+          o[excl] = o[lim];
+          delete o[lim];
+        } else delete o[excl];
+      }
+    }
+    for (const k of Object.keys(o)) o[k] = draft2020(o[k]);
+    return o;
   }
-  return problems;
+  return node;
+}
+function mcpInputSchema(s) {
+  const schema = zodToJsonSchema(s, { target: "jsonSchema2019-09", $refStrategy: "none" });
+  delete schema.$schema;
+  return draft2020(schema);
+}
+var CreateGoalSchema = z.object({
+  outcome: z.string().trim().min(1).max(1e4),
+  ownerParticipant: z.string().trim().min(1).optional(),
+  idempotencyKey: z.string().trim().min(1).max(200)
+});
+var fmtMin = (m) => m >= 60 ? `${m / 60} hr` : `${m} min`;
+var STANDARD_MEANS = (() => {
+  const plan = MISSED_CALL_PLAN.backoff_standard;
+  const mins = plan.kind === "at" ? plan.minutes : [];
+  const parts = mins.map(fmtMin);
+  const list = parts.length > 1 ? `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}` : parts[0] ?? "";
+  return `Rings again ${list} after the missed call, then leaves it in your inbox`;
+})();
+function contactSchemaFrom(fields) {
+  const surface = z.object({
+    ask: fields.ask.describe(
+      `What to tell the user, or what you need to find out from them. Plain prose \u2014 as long as it needs to be (up to 10k characters); Paigy splits it into topics and reads back a few sentences at a time, so do NOT compress a briefing into one line. May be spoken aloud on a call, so write natural speech and name things (not IDs). Contact at exactly two moments: BLOCKED on a decision only they can make, or DONE (one short report \u2014 what shipped, how you verified it, what you flagged). DONE IS SAID ONCE: "all set", "nothing open on my end", "that thread is complete" are the same report in new words, and each one reaches them separately (live 2026-08-12: three of them in three minutes). After the first, you are finished speaking; if they acknowledge it, stop rather than confirming the acknowledgement. Progress is never a contact: set_work_state carries it, and working narration stays in your own terminal \u2014 the user sees you're working without being interrupted by it.`
+    ),
+    waiting: fields.waiting.describe(
+      "What happens to your work while you wait. 'none': you're just informing them. 'soft': you'd like an answer but can keep working. 'hard': you are STOPPED until they answer \u2014 reaches them urgently and escalates to a real phone call if unanswered."
+    ),
+    options: fields.options.describe(
+      `The choices the user picks from, when you have them \u2014 ${OPTIONS_MIN} to ${OPTIONS_MAX}, drawn from your own sentence.`
+    ),
+    channel: fields.channel.describe(
+      "Relay how the user explicitly said to reach them ('call me' \u2192 'call', 'just message/text me' \u2192 'message'), or use 'call' when promoting the same quiet ask after it becomes a substantial blocker. Omit otherwise; Paigy picks."
+    ),
+    parentId: fields.parentId.describe(
+      "To continue an earlier conversation, pass the parentId a previous contact or reply returned. Omit to start a new one."
+    ),
+    workId: fields.workId.describe(
+      "The durable Work this contact advances. Pass the workId from check_replies or a prior reply when asking for a decision that blocks that work."
+    )
+  });
+  const out = mcpInputSchema(surface);
+  out.required = ["ask"];
+  return out;
 }
-var ContextSchema = z.object({
-  title: z.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
-  description: z.array(z.string().min(1)).describe(
+var CONTACT_DESCRIPTION = `Reach the user through Paigy \u2014 tell them something, or ask and get their answer. State what you need in \`ask\`, say what happens to your work while you wait in \`waiting\`, and Paigy handles the rest (channel, phrasing, answer format). If the user explicitly asks you to CALL them, send waiting:'hard' and say so in the ask. Returns { notificationId, parentId, workId?, decisionId? } \u2014 pass notificationId to the reply path named by the returned \`message\`, and parentId to a later contact to continue the conversation. When it rang, the reply also carries { ifMissed: { mode, means } }: what the user's own policy does with a call they don't take ("${STANDARD_MEANS}"), so a no-answer tells you how long to wait before coming back. THREADING REPLACES: a threaded follow-up SUPERSEDES your earlier pending items on that thread \u2014 right for updates to one ask, WRONG for a checklist (send independent to-dos un-threaded). A threaded re-send with IDENTICAL content escalates the pending ask in place. If a reply comes back as {kind:'clarify', chunks:[...]}, the user wants more detail \u2014 contact again on the SAME parentId with an expanded ask. BLOCKED ON A DECISION for existing work? Pass that work's \`workId\`; the reply returns the same workId plus a decisionId, so the answer resumes the right outcome. ONE ASK, ONE ROW: never restate a still-pending ask's question inside a NEW contact (e.g. weaving it into a briefing) \u2014 the whole answer settles on the new row and the original can never receive it. Keep waiting on the original (a live call reads every pending ask out separately, each answer routes to its own row), and use \`needs\` for a genuinely multi-part NEW ask. ANSWERABLE, NOT JUST ASKED: when the reply comes back carrying \`plan.units[].needs\`, that unit asked for something it gave the user no way to answer \u2014 'options' means it posed a choice with nothing to choose from, 'visuals' means it asked about something to look at with nothing to look at. Send it again on the SAME parentId with ${OPTIONS_MIN}-${OPTIONS_MAX} options (or the image), drawn from your own sentence. Paigy will not add them for you: a shape it guessed wrong cannot be undone, and you are the one who knows what the real alternatives are. \`units\` reports WHAT BECAME OF YOUR PROSE \u2014 { kept, raw, why }: how many topics Paigy compressed for delivery, how many kept your exact words, and the reason when it kept them (e.g. 'no_output' = compression produced nothing usable, so the user got your raw sentence). It needs no action and is not an error \u2014 read it only when the delivered wording matters to you; a high \`raw\` count means the user is hearing you verbatim.`;
+var ContextSchema = z2.object({
+  title: z2.string().min(1).describe("One-line headline of what you need (required, non-empty)."),
+  description: z2.array(z2.string().min(1)).describe(
     "Semantic chunks of detail (each a standalone, non-empty piece). The user can select chunks to ask you to expand. MAY BE EMPTY: a claim whose whole content is its heading \u2014 a single sentence \u2014 has no body, and saying so beats repeating the heading underneath itself. That repeat is what `min(1)` used to force, at 2x the storage, with every reader subtracting it back out at render time."
   )
 });
-var ParticipantSchema = z.object({
-  kind: z.enum(["human", "agent"]),
-  id: z.string()
+var ParticipantSchema = z2.object({
+  kind: z2.enum(["human", "agent"]),
+  id: z2.string()
 });
-var TransformSchema = z.enum([
+var TransformSchema = z2.enum([
   "structure",
   // shape intent into an answer contract; pick channel/urgency — broker `ask`, `select` shapes, `points`
   "request_more",
@@ -2365,25 +3602,25 @@ var TransformSchema = z.enum([
   "summarize"
   // reduce volume, keep decision value — 30-turn cap, spoken briefing
 ]);
-var OptionSchema = z.object({
-  id: z.string(),
-  label: z.string(),
+var OptionSchema = z2.object({
+  id: z2.string(),
+  label: z2.string(),
   // .describe() flows into the MCP contact JSON schema (zodToJsonSchema), so
   // the constraints below are what an agent reads when deciding to use these.
-  html: z.string().max(16384).describe(
+  html: z2.string().max(16384).describe(
     "Optional sandboxed HTML/CSS preview for a visual 'pick one' (shown in the option card). Untrusted-sandboxed: NO JavaScript, NO external network or images \u2014 inline CSS and data: URIs only; <=16KB. Use for layout/CSS mockups, tables, diffs. For a hosted image use `image` instead."
   ).optional(),
-  image: z.string().url().describe(
+  image: z2.string().url().describe(
     "Optional image URL rendered as the option's preview (plain image, not sandboxed). For agent-generated HTML/CSS mockups, use `html` instead."
   ).optional()
 });
-var VisualSchema = z.object({
-  url: z.string().url(),
-  label: z.string().optional()
+var VisualSchema = z2.object({
+  url: z2.string().url(),
+  label: z2.string().optional()
 });
-var NotifyLevelSchema = z.enum(["inbox", "push", "banner", "call"]);
-var SelectShapeSchema = z.enum(["one", "many", "rank", "confirm", "text"]);
-var ReceiptEventSchema = z.enum([
+var NotifyLevelSchema = z2.enum(["inbox", "push", "banner", "call"]);
+var SelectShapeSchema = z2.enum(["one", "many", "rank", "confirm", "text"]);
+var ReceiptEventSchema = z2.enum([
   "delivered",
   // the bundle reached the recipient at some level
   "seen",
@@ -2413,41 +3650,44 @@ var ReceiptEventSchema = z.enum([
   // be rewound by a writer that forgot to advance it.
   "restarted"
 ]);
-var AttentionSchema = z.object({
+var AttentionSchema = z2.object({
   urgency: NotifyLevelSchema,
   /** The required answer shape, or null for a plain notify that asks nothing back. */
   select: SelectShapeSchema.nullable(),
   /** Coverage contract (#396) — points the answer must address; null = none declared. */
-  points: z.array(z.string()).nullable(),
+  points: z2.array(z2.string()).nullable(),
   /** Whether the ask blocks the sender — what lets arbitration escalate it on silence. */
-  blocking: z.boolean(),
+  blocking: z2.boolean(),
   /** Reserved (MODEL.md lists it): a response deadline. No row column yet — a later Phase 2
    *  slice wires it; optional so today's rows/callers project cleanly. */
-  deadline: z.string().datetime().nullable().optional()
+  deadline: z2.string().datetime().nullable().optional()
 });
-var NotifyRequestSchema = z.object({
+var NotifyRequestFields = z2.object({
   /** Plaintext message content. Present on the plaintext path (today's shape);
    *  ABSENT on the E2EE path, where the sealed `envelope` below carries it. The
    *  superRefine at the bottom enforces exactly one of the two. */
   context: ContextSchema.optional(),
-  options: z.array(OptionSchema.omit({ id: true })).min(1).optional().describe(
+  options: z2.array(OptionSchema.omit({ id: true })).min(OPTIONS_MIN).max(OPTIONS_MAX).optional().describe(
     "The choices, in order \u2014 required when select is 'one'/'many'/'rank', omitted otherwise. Ids are assigned automatically by position ('1', '2', \u2026); the user's answer references them as optionId(s)."
   ),
-  points: z.array(z.string().min(1)).optional().describe(
+  points: z2.array(z2.string().min(1)).optional().describe(
     "The distinct things you need answered, each a short phrase \u2014 on a call the broker keeps the conversation going until each is addressed, and the reply reports which were covered, so a half-answer is never silently returned as final. Omit for single-part asks."
   ),
-  visuals: z.array(VisualSchema).optional().describe(
+  visuals: z2.array(VisualSchema).optional().describe(
     "Images attached to the message itself \u2014 context for the whole question (a screenshot, a chart). For a preview on one selectable choice, use that option's `html`/`image` instead."
   ),
   /** Git repo the agent is working in ("owner/name"). Local MCP fills this from the checkout — omit unless overriding. */
-  repo: z.string().optional(),
+  repo: z2.string().optional(),
   /** Git branch the agent is on. Local MCP fills this from the checkout — omit unless overriding. */
-  branch: z.string().optional(),
+  branch: z2.string().optional(),
   /** Continue an existing conversation — the id of any notification in it (its root
    *  is the conversation's identity). Omitted = start a new conversation. Renamed
    *  from `parentId` (2026-08-03): one linkage system, the parent; the API edge
    *  still accepts the old name from older clients. */
-  parentId: z.string().uuid().optional(),
+  parentId: z2.string().uuid().optional(),
+  /** The durable outcome this contact advances. Optional during the notification-to-Work
+   *  migration; when present, a blocking ask creates a DecisionNeed for this Work. */
+  workId: z2.string().uuid().optional(),
   urgency: NotifyLevelSchema.default("inbox").describe(
     "The level you're requesting \u2014 the user's account permissions + session mode can lower it. 'inbox' (default) = sits silently in the inbox for the user to get to. 'push' = a quiet passive push (lands in Notification Center, no sound) \u2014 a gentle heads-up. 'banner' = a time-sensitive banner/lock-screen push with sound (a 'paige') they tap to open \u2014 use when you need them soon-ish but it's not worth ringing them. 'call' = rings the user's phone now (a CallKit voice call) \u2014 use only when you genuinely need them in the moment (blocked and waiting, time-sensitive). context.title is what they see on the banner/ring, so make it specific."
   ),
@@ -2455,7 +3695,7 @@ var NotifyRequestSchema = z.object({
    *  visible and marks it needs_input. Renamed from the old `parentId` (2026-08-03)
    *  when `parentId` became the conversation handle: `parentId` says WHERE, this
    *  says HOW. */
-  clarifies: z.string().optional(),
+  clarifies: z2.string().optional(),
   /** E2EE (text lane): when the pairing is E2EE, the sealed replacements for the
    *  plaintext content fields, keyed by field name. FINALIZED wire shape (was
    *  provisional in the storage PR): a per-field map `{ context?, options?,
@@ -2468,10 +3708,10 @@ var NotifyRequestSchema = z.object({
    *  notifications.envelope and relays it blindly; it never decrypts. Absent =
    *  today's plaintext path (context/options/visuals carry the cleartext).
    *  z.lazy because EnvelopeSchema is declared further down (E2EE section). */
-  envelope: z.object({
-    context: z.lazy(() => EnvelopeSchema).optional(),
-    options: z.lazy(() => EnvelopeSchema).optional(),
-    visuals: z.lazy(() => EnvelopeSchema).optional()
+  envelope: z2.object({
+    context: z2.lazy(() => EnvelopeSchema).optional(),
+    options: z2.lazy(() => EnvelopeSchema).optional(),
+    visuals: z2.lazy(() => EnvelopeSchema).optional()
   }).optional(),
   select: SelectShapeSchema.optional().describe(
     "How the user answers \u2014 required on the fully-shaped form, pick the shape that fits the question: 'one' = pick one option, 'many' = pick several, 'rank' = pick & order (each needs `options`); 'confirm' = yes/no or approve/deny; 'text' = free-form reply only (status updates, open questions). 'confirm' and 'text' take no options. Omit only when sending the simplified `ask` form \u2014 the broker picks the shape."
@@ -2486,20 +3726,20 @@ var NotifyRequestSchema = z.object({
   // (broker/agenda-design.md) — not by a wire cap the agent has to pre-summarize under.
   // Owner, 2026-07-28: "our actual limitation on how long something is to the user should
   // come from the broker splitting and summarizing." The cap that remains is a size guard.
-  ask: z.string().min(1).max(1e4).optional().describe(
+  ask: z2.string().min(1).max(1e4).optional().describe(
     'SIMPLIFIED FORM \u2014 state in plain prose what you need to learn from the user and why it matters now (e.g. "I need to know whether to deploy the auth fix \u2014 tests are green, staging verified"). Write as much as the situation needs (up to 10k characters) \u2014 Paigy breaks it into topics and reads it back a few sentences at a time; do NOT pre-summarize it into one line. Paigy derives the title, answer shape, options, and delivery channel for you. Mutually exclusive with context/select/options \u2014 send one form or the other.'
   ),
-  needs: z.array(z.string().min(1)).optional().describe(
+  needs: z2.array(z2.string().min(1)).optional().describe(
     "With `ask` only: the distinct things you need answered when the ask is multi-part \u2014 becomes the coverage contract (`points`), so a half-answer is never silently final."
   ),
-  urgencyHint: z.enum(["whenever", "soon", "now"]).optional().describe(
+  urgencyHint: z2.enum(["whenever", "soon", "now"]).optional().describe(
     "With `ask` only: how urgently you need the answer \u2014 'whenever' (inbox), 'soon' (worth a heads-up), 'now' (you're blocked this minute). A hint, not a command: the user's settings still have the final word."
   ),
   /** #575: the ONE self-report that replaces urgencyHint + blocking — what happens
    *  to the agent's work while it waits. Normalized server-side into those two
    *  fields (normalizeWaiting) so everything downstream is untouched; explicit
    *  urgencyHint/blocking win when both are sent. */
-  waiting: z.enum(["none", "soft", "hard"]).optional().describe(
+  waiting: z2.enum(["none", "soft", "hard"]).optional().describe(
     "With `ask`: what happens to your work while you wait. 'none' = you're just informing the user. 'soft' = you'd like an answer but can keep working. 'hard' = you are stopped until they answer (reaches them urgently and escalates to a real phone call if unanswered). Replaces urgencyHint + blocking \u2014 send this one field."
   ),
   /** Δ9b (#895): HOLD this claim so the sender can correct the plan before anyone is
@@ -2507,57 +3747,58 @@ var NotifyRequestSchema = z.object({
    *  holding by default would charge every quiet claim that minute before any agent could
    *  correct anything. Ignored for `waiting: 'hard'`: a blocking ask rings on what we have,
    *  and the enrichment can still land mid-call (#781 re-plans the unspoken tail). */
-  confirm: z.boolean().optional().describe(
+  confirm: z2.boolean().optional().describe(
     "Hold this one so you can correct the plan before the user is interrupted. The response comes back with `held: true` and the plan; POST the confirm route to release it (with options/visuals/urgency corrections, or nothing at all). If you never do, it is announced anyway a couple of minutes later. Ignored when waiting is 'hard'."
   ),
   /** #575: a RELAY of the user's explicitly stated preference, never the agent's
    *  choice. Outranks waiting in both directions: 'call' rings even for a
    *  waiting:'none' "call me when it's done"; 'message' never rings even for
    *  waiting:'hard'. */
-  channel: z.enum(["call", "message"]).optional().describe(
+  channel: z2.enum(["call", "message"]).optional().describe(
     "Only if the user explicitly said how to reach them \u2014 'call me' \u2192 'call', 'just message/text me' \u2192 'message'. Omit otherwise; Paigy picks."
   ),
-  confirmStyle: z.enum(["yesno", "approve"]).default("yesno").describe(
+  confirmStyle: z2.enum(["yesno", "approve"]).default("yesno").describe(
     "Labels for a select:'confirm' paige \u2014 'yesno' (Yes/No) or 'approve' (Approve/Deny). Ignored unless select is 'confirm'."
   ),
-  blocking: z.boolean().default(false).describe(
+  blocking: z2.boolean().default(false).describe(
     "Set true when real downstream work is stuck behind this specific decision \u2014 you can't make meaningful progress until it's answered. This is the real signal for how urgently the user should be reached; it's what the premier use case (an agent that stays unblocked instead of going idle) depends on. Independent of `urgency`: a `banner`-level question can still be `blocking` (something IS stuck, just not time-critical enough to ring for immediately) \u2014 if it goes unanswered a while, Paigy escalates it to a real call using this flag rather than guessing from how many other things happen to be pending. Leave false for anything you could work around, defer, or where other useful work exists meanwhile."
   )
-}).superRefine((r, ctx) => {
+});
+var NotifyRequestSchema = NotifyRequestFields.superRefine((r, ctx) => {
   const sealed = !!r.envelope;
   if (sealed) {
     if (!r.envelope?.context)
-      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["envelope", "context"], message: "sealed request must include envelope.context" });
+      ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["envelope", "context"], message: "sealed request must include envelope.context" });
     for (const f of ["context", "options", "visuals"]) {
       if (r[f] !== void 0)
-        ctx.addIssue({ code: z.ZodIssueCode.custom, path: [f], message: `E2EE request must not carry plaintext ${f} \u2014 it's sealed in envelope.${f}` });
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: [f], message: `E2EE request must not carry plaintext ${f} \u2014 it's sealed in envelope.${f}` });
     }
     if (r.points !== void 0)
-      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["points"], message: "E2EE request must not carry plaintext points" });
+      ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["points"], message: "E2EE request must not carry plaintext points" });
     if (r.ask !== void 0)
-      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["ask"], message: "E2EE request must not carry a plaintext ask \u2014 derive the shape agent-side and seal it" });
+      ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["ask"], message: "E2EE request must not carry a plaintext ask \u2014 derive the shape agent-side and seal it" });
     if (r.needs !== void 0)
-      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["needs"], message: "E2EE request must not carry plaintext needs" });
+      ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["needs"], message: "E2EE request must not carry plaintext needs" });
     return;
   }
   if (r.ask !== void 0) {
     for (const f of ["context", "select", "points"]) {
       if (r[f] !== void 0)
-        ctx.addIssue({ code: z.ZodIssueCode.custom, path: [f], message: `the simplified \`ask\` form takes no ${f} \u2014 the broker derives the answer shape from your prose. Drop ${f} and say it in \`ask\` instead ("should I\u2026" for approve/deny, "which of these\u2026" for a pick), passing \`options\` when you're offering concrete alternatives.` });
+        ctx.addIssue({ code: z2.ZodIssueCode.custom, path: [f], message: `the simplified \`ask\` form takes no ${f} \u2014 the broker derives the answer shape from your prose. Drop ${f} and say it in \`ask\` instead ("should I\u2026" for approve/deny, "which of these\u2026" for a pick), passing \`options\` when you're offering concrete alternatives.` });
     }
     return;
   }
   if (r.needs !== void 0 || r.urgencyHint !== void 0)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["needs"], message: "needs/urgencyHint belong to the simplified `ask` form \u2014 with a shaped request use points/urgency" });
+    ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["needs"], message: "needs/urgencyHint belong to the simplified `ask` form \u2014 with a shaped request use points/urgency" });
   if (!r.context)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["context"], message: "context is required (plaintext path)" });
+    ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["context"], message: "context is required (plaintext path)" });
   if (!r.select)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["select"], message: "select is required on the shaped form" });
+    ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["select"], message: "select is required on the shaped form" });
   const needsOptions = r.select === "one" || r.select === "many" || r.select === "rank";
   if (needsOptions && !r.options?.length)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' requires options` });
+    ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' requires options` });
   if (!needsOptions && r.options?.length)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' takes no options` });
+    ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["options"], message: `select:'${r.select}' takes no options` });
 });
 function normalizeWaiting(req) {
   if (!req.waiting) return req;
@@ -2614,61 +3855,70 @@ function deriveAsk(req) {
     ...needs?.length ? { points: needs } : {}
   };
 }
-var NotifyStatusSchema = z.enum(["pending", "answered", "ignored"]);
-var AgentStateSchema = z.enum(["idle", "in_progress", "completed", "needs_input"]);
-var SetTaskStateSchema = z.object({
-  state: z.enum(["in_progress", "completed", "needs_input"])
+var NotifyStatusSchema = z2.enum(["pending", "answered", "ignored"]);
+var AgentStateSchema = z2.enum(["idle", "in_progress", "completed", "needs_input"]);
+var SetTaskStateSchema = z2.object({
+  state: z2.enum(["in_progress", "completed", "needs_input"])
 });
-var TurnSchema = z.object({
-  prompt: z.string(),
-  reply: z.string()
+var SetWorkStateSchema = z2.object({
+  workId: z2.string().uuid().optional(),
+  notificationId: z2.string().optional(),
+  state: SetTaskStateSchema.shape.state
+}).refine((value) => Number(Boolean(value.workId)) + Number(Boolean(value.notificationId)) === 1, {
+  message: "exactly one of workId or notificationId is required"
 });
-var UserAnswerSchema = z.discriminatedUnion("kind", [
-  z.object({ kind: z.literal("option"), optionId: z.string(), label: z.string().optional() }),
-  z.object({ kind: z.literal("text"), text: z.string() }),
-  z.object({ kind: z.literal("ignored") }),
-  z.object({ kind: z.literal("multi"), optionIds: z.array(z.string()), labels: z.array(z.string()).optional() }),
-  z.object({ kind: z.literal("ranked"), optionIds: z.array(z.string()), labels: z.array(z.string()).optional() }),
-  z.object({ kind: z.literal("clarify"), chunks: z.array(z.string()).min(1) }),
-  z.object({ kind: z.literal("confirm"), approved: z.boolean() }),
-  z.object({ kind: z.literal("turns"), turns: z.array(TurnSchema).min(1) }),
+var TurnSchema = z2.object({
+  prompt: z2.string(),
+  reply: z2.string()
+});
+var UserAnswerSchema = z2.discriminatedUnion("kind", [
+  z2.object({ kind: z2.literal("option"), optionId: z2.string(), label: z2.string().optional() }),
+  z2.object({ kind: z2.literal("text"), text: z2.string() }),
+  z2.object({ kind: z2.literal("ignored") }),
+  z2.object({ kind: z2.literal("multi"), optionIds: z2.array(z2.string()), labels: z2.array(z2.string()).optional() }),
+  z2.object({ kind: z2.literal("ranked"), optionIds: z2.array(z2.string()), labels: z2.array(z2.string()).optional() }),
+  z2.object({ kind: z2.literal("clarify"), chunks: z2.array(z2.string()).min(1) }),
+  z2.object({ kind: z2.literal("confirm"), approved: z2.boolean() }),
+  z2.object({ kind: z2.literal("turns"), turns: z2.array(TurnSchema).min(1) }),
   /** An auto-answer derived from the user's PAST decisions (broker/precedent-design.md §2):
    *  delivered through the same settle/await path as a human answer, carrying the judge's
    *  derivation and the precedent ids it grew from. Always paired with a visible trail
    *  card the user can reply to — the broker never overrides the user. */
-  z.object({ kind: z.literal("precedent"), answer: z.string(), derivation: z.string(), sources: z.array(z.string()).min(1) })
+  z2.object({ kind: z2.literal("precedent"), answer: z2.string(), derivation: z2.string(), sources: z2.array(z2.string()).min(1) })
 ]);
-var IntentSchema = z.object({
+var IntentSchema = z2.object({
   // The full vocabulary the bot's mapper emits (mapper.INTENT_KINDS) — the schema lagged
   // it by two ("detail", "feedback"), and because the settle handler parsed the array
   // all-or-nothing, ONE feedback act silently dropped EVERY intent on the call,
   // questions included. Found auditing five calls' stored feedback, 2026-08-01.
-  kind: z.enum(["defer", "delegate", "channel", "question", "detail", "feedback", "command", "control"]),
-  detail: z.string(),
-  /** Landed defer (#397): the MCP parses common spoken forms ("in 20 minutes",
-   *  "after lunch") against the agent machine's clock — the user's — and attaches
-   *  the seconds, ready to pass straight to schedule_callback. Absent when the
-   *  detail didn't parse (the agent interprets it) or the kind isn't defer. */
-  dueInSeconds: z.number().int().positive().optional(),
+  kind: z2.enum(["defer", "delegate", "channel", "question", "detail", "feedback", "command", "control"]),
+  detail: z2.string(),
+  /** Defer only: seconds until the callback the caller asked for, when something upstream
+   *  already read the time. Nothing sets it today (#397 documented an MCP parser that was
+   *  never written) — the API reads the defer's `detail` itself with `notes/when.ts`
+   *  (`parseDelay`, #1292), and a value here simply wins over that reading. */
+  dueInSeconds: z2.number().int().positive().optional(),
   /** Feedback only (#812): WHICH failure the complaint names — typed by the mapper that
    *  already read the utterance, so `feedback_from_call.kind` stops defaulting to
    *  'other' on every row. A table that records that something was wrong and nothing
    *  about what cannot answer "is the bot looping less this week?". */
-  fault: z.enum(["loop", "unanswered", "overridden", "misheard", "slow", "other"]).optional()
+  fault: z2.enum(["loop", "unanswered", "overridden", "misheard", "slow", "other"]).optional()
 });
-var RideAlongSchema = z.object({
+var RideAlongSchema = z2.object({
   /** The note this came from — assign/clarify/close it through /api/notes/:id. */
-  noteId: z.string(),
+  noteId: z2.string(),
   /** What to do, in the owner's own words (the note's headline). Never model-rewritten. */
-  text: z.string(),
+  text: z2.string(),
   /** The thread to report back on, when the note was dispatched over the request rail. */
-  parentId: z.string().nullable()
+  parentId: z2.string().nullable()
 });
-var AwaitItemSchema = z.discriminatedUnion("type", [
-  z.object({
-    type: z.literal("reply"),
-    parentId: z.string(),
-    notificationId: z.string(),
+var AwaitItemSchema = z2.discriminatedUnion("type", [
+  z2.object({
+    type: z2.literal("reply"),
+    parentId: z2.string(),
+    notificationId: z2.string(),
+    workId: z2.string().uuid().optional(),
+    decisionId: z2.string().uuid().optional(),
     answer: UserAnswerSchema,
     /** E2EE: present when the answer is sealed. The server relays the opaque answer
      *  envelope + the plaintext `ignored` status hint; the receiving agent OPENS it
@@ -2676,126 +3926,146 @@ var AwaitItemSchema = z.discriminatedUnion("type", [
      *  against `ignored` as tampering. Absent = today's plaintext answer (in `answer`).
      *  On a sealed reply the plaintext `answer` is a placeholder (kind reflects only
      *  the `ignored` bit) — never the real content, which stays sealed. */
-    sealed: z.lazy(() => SealedAnswerSchema).optional(),
-    /** Broker extras (#381), present when the answer was mapped from a call: next
-     *  steps the user attached ("call me after lunch" → defer — act on it via
-     *  schedule_callback) and the raw words the shaped answer was mapped from. */
-    intents: z.array(IntentSchema).optional(),
-    transcript: z.string().optional(),
+    sealed: z2.lazy(() => SealedAnswerSchema).optional(),
+    /** WHAT THE AGENT CANNOT KNOW FROM THE FIELDS BESIDE IT (owner, 2026-09-04, issue
+     *  #1537). One line, built from the record: the ask and the caller's reply VERBATIM,
+     *  the notification they belong to, and the `contact` call that reaches the person
+     *  again, spelled with its real arguments. It restates nothing — deleting the brain's
+     *  acts deleted the paraphrase, and this is not it coming back: an agent that reads
+     *  "call me back after you merge" in their own words decides for itself what to do,
+     *  and now knows exactly which call to make. Absent when either half is missing —
+     *  a sentence with a hole in it is worse than no sentence. */
+    note: z2.string().optional(),
+    /** The call record rendered for THIS agent (`voice/record-design.md`): the words the
+     *  shaped answer was mapped from, filtered to its own claims. There is no second list
+     *  of labels beside it — the acts went 2026-09-04 and `intents` went with them (owner,
+     *  2026-09-04): the agent reads the sentence and decides. */
+    transcript: z2.string().optional(),
     /** Coverage report (#396), when the ask declared `points`: which of them this
      *  answer addressed. Missing points = re-ask or proceed knowingly partial. */
-    covered: z.array(z.string()).optional(),
+    covered: z2.array(z2.string()).optional(),
     /** Ride-alongs (RideAlongSchema) — pending work for you, attached to the moment you
      *  became free. Only `reply` and `idle` carry it: those are the two outcomes that
      *  END a wait. `remind`, `superseded` and `turn` are mid-flight, and handing an
      *  agent a side-quest while it is still holding the line is how the main thing gets
      *  dropped. Absent/empty = nothing owed. */
-    also: z.array(RideAlongSchema).optional()
+    also: z2.array(RideAlongSchema).optional()
   }),
-  z.object({
-    type: z.literal("remind"),
-    parentId: z.string(),
-    notificationId: z.string(),
-    remindAt: z.string().datetime({ offset: true }),
+  z2.object({
+    type: z2.literal("remind"),
+    parentId: z2.string(),
+    notificationId: z2.string(),
+    remindAt: z2.string().datetime({ offset: true }),
     /** Seconds until remindAt, server-computed — pass straight to ScheduleWakeup. */
-    remindInSeconds: z.number()
+    remindInSeconds: z2.number()
   }),
   /** The awaited ask was REPLACED by a newer notification on its thread (e.g. a
    *  post-feedback revision, #633) — the user will never answer this id. Stop
    *  awaiting it; the live ask is the thread's newest turn (await that one, or
    *  re-orient via get_thread / check_replies). */
-  z.object({
-    type: z.literal("superseded"),
-    parentId: z.string(),
-    notificationId: z.string()
+  z2.object({
+    type: z2.literal("superseded"),
+    parentId: z2.string(),
+    notificationId: z2.string()
   }),
   /** A LIVE call's turn, streamed as it lands (#783). PROVISIONAL: the user can still
    *  revise any of these until the final reply arrives — partial = intelligence,
    *  settled = authorization. Use it to PREPARE (fetch, draft, warm), never to act
    *  irreversibly. If `acts` carries a question aimed at you and you know the answer,
    *  contact on the same thread right away — the caller hears it on the same call. */
-  z.object({
-    type: z.literal("partial"),
-    notificationId: z.string(),
-    inFlight: z.literal(true),
-    turn: z.object({
-      idx: z.number(),
-      prompt: z.string(),
-      reply: z.string(),
-      acts: z.array(IntentSchema).nullable().optional()
+  z2.object({
+    type: z2.literal("partial"),
+    notificationId: z2.string(),
+    inFlight: z2.literal(true),
+    turn: z2.object({
+      idx: z2.number(),
+      prompt: z2.string(),
+      reply: z2.string(),
+      acts: z2.array(IntentSchema).nullable().optional()
     })
   }),
-  z.object({ type: z.literal("idle"), also: z.array(RideAlongSchema).optional() })
+  z2.object({ type: z2.literal("idle"), also: z2.array(RideAlongSchema).optional() })
 ]);
-var CallbackTriggerSchema = z.enum(["on_done", "on_blocked", "scheduled"]);
-var ScheduleCallbackSchema = z.object({
-  parentId: z.string().describe("The thread to call back on (from a prior contact / reply / request)."),
+var CallbackTriggerSchema = z2.enum(["on_done", "on_blocked", "scheduled"]);
+var ScheduleCallbackSchema = z2.object({
+  parentId: z2.string().describe("The thread to call back on (from a prior contact / reply / request)."),
   trigger: CallbackTriggerSchema,
-  dueInSeconds: z.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
-  note: z.string().optional().describe("What to tell the user when you follow up.")
+  dueInSeconds: z2.number().int().positive().optional().describe("For 'scheduled' only: how many seconds from now to fire."),
+  note: z2.string().optional().describe("What to tell the user when you follow up.")
 });
-var PendingRepliesSchema = z.object({
-  replies: z.array(
-    z.object({
-      parentId: z.string(),
-      notificationId: z.string(),
+var PendingRepliesSchema = z2.object({
+  replies: z2.array(
+    z2.object({
+      parentId: z2.string(),
+      notificationId: z2.string(),
+      workId: z2.string().uuid().optional(),
+      decisionId: z2.string().uuid().optional(),
       answer: UserAnswerSchema,
       /** E2EE: the sealed answer (opaque envelope + plaintext `ignored` hint) when the
        *  pairing is E2EE — the agent opens it and re-derives the real answer. Absent =
        *  plaintext answer (in `answer`). See AwaitItemSchema's reply variant. */
-      sealed: z.lazy(() => SealedAnswerSchema).optional(),
-      /** Broker extras (#381): next steps the user attached to a call-mapped answer
-       *  ("call me after lunch" → defer — act on it via schedule_callback) and the
-       *  raw words the shaped answer was mapped from. */
-      intents: z.array(IntentSchema).optional(),
-      transcript: z.string().optional(),
+      sealed: z2.lazy(() => SealedAnswerSchema).optional(),
+      /** The call record rendered for THIS agent: the raw words the shaped answer was
+       *  mapped from, filtered to its own claims. See AwaitItemSchema's reply variant. */
+      transcript: z2.string().optional(),
       /** Coverage report (#396): which declared `points` this answer addressed. */
-      covered: z.array(z.string()).optional()
+      covered: z2.array(z2.string()).optional()
     })
   ),
-  pending: z.array(
-    z.object({ parentId: z.string(), notificationId: z.string(), createdAt: z.string() })
+  pending: z2.array(
+    z2.object({ parentId: z2.string(), notificationId: z2.string(), createdAt: z2.string() })
   ),
   /** WHO YOU ARE on this account (field report 2026-08-28): the name and device the user
    *  sees for this session's identity. From inside a session there was no way to find out —
    *  `pair` with no arguments can HATCH a fresh identity, so it is not a safe probe — and an
    *  agent that cannot tell which agent it is cannot tell whether work addressed to
    *  "Reta" was addressed to it. Absent only for a token with no pairing behind it. */
-  you: z.object({ name: z.string(), device: z.string().nullable(), tokenId: z.string() }).optional(),
+  you: z2.object({ name: z2.string(), device: z2.string().nullable(), tokenId: z2.string() }).optional(),
   /** User-initiated requests addressed to this agent; act on them and reply via
    *  contact on the same parentId. Keeps reappearing until you call
-   *  set_task_state on its notificationId. */
-  requests: z.array(
-    z.object({
-      parentId: z.string(),
-      notificationId: z.string(),
-      text: z.string(),
-      createdAt: z.string(),
+   *  set_work_state on its workId (or notificationId once while bootstrapping). */
+  requests: z2.array(
+    z2.object({
+      parentId: z2.string(),
+      notificationId: z2.string(),
+      workId: z2.string().uuid().optional(),
+      text: z2.string(),
+      createdAt: z2.string(),
       /** The user seeded this request with a past conversation — call get_thread on it
        *  FIRST and treat the transcript as prior context (#57/#251). */
-      contextParentId: z.string().optional(),
+      contextParentId: z2.string().optional(),
       /** STRANDED (field report 2026-08-28): this request was addressed to ANOTHER agent on
        *  the account — the name here — which has not been seen since it landed, so nobody
        *  came for it. Handed to you because you are the session that is here. Take it like
-       *  any request (set_task_state claims it, reply with contact on its parentId), and say
+       *  any request (set_work_state claims it, reply with contact on its parentId), and say
        *  whose it was, because the user chose that agent on purpose. */
-      stranded: z.string().optional()
+      stranded: z2.string().optional()
     })
   ),
+  /** Durable outcomes currently owned by this agent. This is the Work-native queue; flat
+   * notification lists remain during migration so old clients keep their existing view. */
+  work: z2.array(z2.object({
+    workId: z2.string().uuid(),
+    parentId: z2.string().optional(),
+    objective: z2.string().nullable(),
+    state: z2.enum(["active", "blocked", "waiting_external"]),
+    blockedOn: z2.array(z2.string().uuid()),
+    updatedAt: z2.string()
+  })).optional(),
   /** Callbacks you owe the user that are now DUE (you said you'd follow up when done,
    *  if blocked, or at a time that has passed). Re-surfaced every sweep until you
    *  fulfill one by calling contact on its parentId. */
   /** Ride-alongs (RideAlongSchema): notes assigned to this agent that no wake could
    *  reach. Same array the contact/await replies carry — one queue, every carrier. */
-  also: z.array(RideAlongSchema).optional(),
-  owedCallbacks: z.array(
-    z.object({ parentId: z.string(), trigger: CallbackTriggerSchema, note: z.string() })
+  also: z2.array(RideAlongSchema).optional(),
+  owedCallbacks: z2.array(
+    z2.object({ parentId: z2.string(), trigger: CallbackTriggerSchema, note: z2.string() })
   ),
   /** Work (either direction) you reported in_progress a while ago and never reported
    *  completed — likely left half-done by this session or a prior one that crashed or
-   *  went idle. Report a real state (set_task_state) or continue the work. */
-  stalled: z.array(
-    z.object({ parentId: z.string(), notificationId: z.string(), title: z.string().nullable(), startedAt: z.string() })
+   *  went idle. Report a real state (set_work_state) or continue the work. */
+  stalled: z2.array(
+    z2.object({ parentId: z2.string(), notificationId: z2.string(), title: z2.string().nullable(), startedAt: z2.string() })
   ),
   /** The queue rail (#614, pending/design.md): the same replies + requests, grouped by
    *  thread and ordered oldest-thread-first, so you work ONE thread at a time — fold all of
@@ -2804,123 +4074,125 @@ var PendingRepliesSchema = z.object({
    *  ride the next turn. `items` are that thread's replies/requests in arrival order; the
    *  full payload for each is in the flat `replies`/`requests` arrays (matched by
    *  notificationId). Derived, never stored — a crashed agent recomputes it exactly. */
-  threads: z.array(
-    z.object({
-      parentId: z.string(),
-      busy: z.boolean(),
-      items: z.array(
-        z.object({
-          kind: z.enum(["reply", "request"]),
-          notificationId: z.string(),
-          at: z.string()
+  threads: z2.array(
+    z2.object({
+      parentId: z2.string(),
+      busy: z2.boolean(),
+      items: z2.array(
+        z2.object({
+          kind: z2.enum(["reply", "request"]),
+          notificationId: z2.string(),
+          at: z2.string()
         })
       )
     })
   )
 });
-var NotifyResponseSchema = z.object({
-  notificationId: z.string(),
+var NotifyResponseSchema = z2.object({
+  notificationId: z2.string(),
+  workId: z2.string().uuid().optional(),
+  decisionId: z2.string().uuid().optional(),
   status: NotifyStatusSchema,
-  createdAt: z.string().datetime(),
+  createdAt: z2.string().datetime(),
   answer: UserAnswerSchema.optional(),
-  answeredAt: z.string().datetime().optional(),
+  answeredAt: z2.string().datetime().optional(),
   /** Ride-alongs for THIS agent — pending work it should pick up when it's done with
    *  what it came for. Present on any reply, because an unwakeable agent's only
    *  reliable moment is one it initiated. Absent/empty = nothing owed. */
-  also: z.array(RideAlongSchema).optional()
+  also: z2.array(RideAlongSchema).optional()
 });
-var NotifyPlanUnitSchema = z.object({
-  notificationId: z.string(),
+var NotifyPlanUnitSchema = z2.object({
+  notificationId: z2.string(),
   /** The unit's own heading, so the agent can tell which of its paragraphs this became. */
-  title: z.string(),
+  title: z2.string(),
   /** How loudly this unit was arbitrated to arrive — per unit, which is the point of units. */
   level: NotifyLevelSchema,
   /** Answered from something the user already decided: nobody is interrupted, and a trail card
    *  says so. The agent should not wait on this one. */
-  settled: z.literal(true).optional(),
+  settled: z2.literal(true).optional(),
   /** What this unit would need to be answerable and does not carry (#894). A PROPOSAL to the
    *  agent — nothing here changed the ask, and ignoring it costs nothing. */
-  needs: z.array(z.enum(["options", "visuals"])).optional(),
+  needs: z2.array(z2.enum(["options", "visuals"])).optional(),
   /** The SHAPE the broker would give this unit, for the agent to ratify (#886/#894). The
    *  split layer reads prose and can see that a paragraph is a yes/no or a pick-one — but a
    *  broker that DECIDES that destroys the only fact separating a statement from a real ask
    *  (#731), so it is offered, never applied: the unit is stored `text` until the agent
    *  confirms the shape (POST /notify/:id/confirm). Ignoring it costs nothing. */
-  proposal: z.object({
+  proposal: z2.object({
     select: SelectShapeSchema,
-    options: z.array(z.object({ label: z.string().min(1) })).optional()
+    options: z2.array(z2.object({ label: z2.string().min(1) })).optional()
   }).optional(),
   /** What the broker READ this unit as wanting from the human (#952 layer 2): a `decision`
    *  between alternatives, an `approval` the agent is blocked on, or `knowledge` it just
    *  needs to know. Reported so the agent can correct a misread the same way it ratifies a
    *  shape — the read RAISES (a decision always asks) and never silences a question the
    *  agent declared (#731, #923). */
-  wants: z.enum(["decision", "approval", "knowledge"]).optional()
+  wants: z2.enum(["decision", "approval", "knowledge"]).optional()
 });
-var NotifyPlanSchema = z.object({
-  units: z.array(NotifyPlanUnitSchema),
+var NotifyPlanSchema = z2.object({
+  units: z2.array(NotifyPlanUnitSchema),
   /** Which unit is this arrival's ONE interruption (units-design.md D23). Absent means nobody
    *  was interrupted — every unit was either settled or quiet enough to sit in the inbox. */
-  speaks: z.string().optional()
+  speaks: z2.string().optional()
 });
-var UserResponseSchema = z.object({
-  requestId: z.string(),
+var UserResponseSchema = z2.object({
+  requestId: z2.string(),
   answer: UserAnswerSchema,
-  answeredAt: z.string().datetime(),
-  intents: z.array(IntentSchema).optional(),
-  transcript: z.string().optional(),
+  answeredAt: z2.string().datetime(),
+  transcript: z2.string().optional(),
   /** E2EE: the sealed answer (opaque envelope + plaintext `ignored` hint) when the item was
    *  E2EE-sealed. Present → the server persists it opaquely and branches status on `ignored`;
    *  the plaintext `answer` is a placeholder (`{ kind: "ignored" }`) the server ignores for a
    *  sealed row. Absent = today's plaintext answer, unchanged. */
-  sealed: z.lazy(() => SealedAnswerSchema).optional(),
+  sealed: z2.lazy(() => SealedAnswerSchema).optional(),
   /** Coverage report (#396): which of the ask's declared `points` were addressed. */
-  covered: z.array(z.string()).optional()
+  covered: z2.array(z2.string()).optional()
 });
-var VoiceKeySchema = z.enum(["rachel", "george", "jessica", "brian", "lily"]);
-var AgendaTurnSchema = z.object({
+var VoiceKeySchema = z2.enum(["rachel", "george", "jessica", "brian", "lily"]);
+var AgendaTurnSchema = z2.object({
   /** Twin coverage (#1089): sibling claim ids this asking turn's answer ALSO settles —
    *  the planner declares duplicates instead of asking them twice. */
-  coveredIds: z.array(z.string()).optional(),
+  coveredIds: z2.array(z2.string()).optional(),
   /** At most three short spoken sentences. Capped because a turn is a breath: a 1031-char
    *  line went out on 2026-07-28 and the caller could not answer it at all. */
-  info: z.array(z.string().min(1)).max(3).default([]),
-  question: z.string().min(1).nullable(),
+  info: z2.array(z2.string().min(1)).max(3).default([]),
+  question: z2.string().min(1).nullable(),
   /** True on the one turn carrying the agent's own declared question. */
-  asks: z.boolean().optional(),
+  asks: z2.boolean().optional(),
   /** The claim this turn belongs to (#781) — the RETURN identity: answers route by it.
    *  Absent on a single-claim plan (the session's own claim) and on shared context turns,
    *  which route nothing. */
-  claimId: z.string().optional(),
+  claimId: z2.string().optional(),
   /** The claim's voice key (#462) — the OUTBOUND identity, audible who-is-asking. */
-  voice: z.string().optional(),
+  voice: z2.string().optional(),
   /** The claim's AGENT NAME (#838) — the spoken identity. A voice alone doesn't say
    *  whose request this is: an item that folded in from another agent arrived as a bare
    *  non-sequitur ("First real production sign-in is yours to make whenever you want.")
    *  and the owner answered "What?". The bot names the agent before its first turn. */
-  agent: z.string().optional(),
+  agent: z2.string().optional(),
+  /** The claim's agent by ID — the pairing's connection id (`notifications.token_id`), the
+   *  same id a face is minted from. A name is not an identity: two pairings may be called
+   *  "Claude", and a name cannot be joined on. The record's entries carry it (`agent_id`)
+   *  so "who said that" survives the call, and it rides PER TURN because a coalesced call
+   *  speaks for several agents — the turn is the only place that knows which. */
+  agentId: z2.string().optional(),
   select: SelectShapeSchema.optional(),
-  options: z.array(OptionSchema.omit({ id: true })).optional(),
-  /** The seat was satisfied by the call's own ACCOUNT (replan-design.md, user_info): the
-   *  caller already answered this claim in an earlier utterance, quoted here VERBATIM —
-   *  the bot speaks the turn's short confirmation, posts these words as the claim's
-   *  answer, and never re-asks. Grounded at parse time: an invented settle is #796. */
-  settle: z.string().optional(),
+  options: z2.array(OptionSchema.omit({ id: true })).optional(),
   /** Pacing (#826, owner 2026-08-03: "how fast we move through them ... are parameters"):
    *  seconds the floor stays open after this turn speaks. Absent = the bot's defaults
    *  (the beat for context, the answer window for asks). Clamped bot-side. */
-  pace: z.number().positive().optional(),
+  pace: z2.number().positive().optional(),
   /** Whether the walk WAITS for an answer before moving on. Absent = derived as today
    *  (a question blocks, context flows). blocking:false on a question = ask and move
    *  on, the claim stays pending; blocking:true on context = hold for a reply. */
-  blocking: z.boolean().optional()
+  blocking: z2.boolean().optional()
 });
 var CLAIM_STALE_MS = 30 * 6e4;
-var InboxItemSchema = z.object({
-  id: z.string(),
+var InboxItemSchema = z2.object({
+  id: z2.string(),
   /** The conversation thread + connection this item lives on. Present on the replied
    *  detail — they power History's "Continue" / "New session from this" (#57/#251). */
-  parentId: z.string().optional(),
+  parentId: z2.string().optional(),
   /** THE ARRIVAL this row is one unit of (`notifications.ask_id` → `asks`). A claim is one
    *  arrival and its units are N rows of it, so this — not `parentId` — is what makes a
    *  multi-part notification one thing on screen. The thread is the whole CONVERSATION: it
@@ -2928,13 +4200,13 @@ var InboxItemSchema = z.object({
    *  unrelated updates as a single "12-part request". Absent on rows written before the
    *  `asks` table, and on anything that never went through `notify` — both fall back to the
    *  thread, which is what the client did for all rows until now. */
-  askId: z.string().optional(),
+  askId: z2.string().optional(),
   /** WHERE this unit sat in the message it was cut from (`notifications.seq`). The batch
    *  shares one `created_at` to the microsecond, so without it the author's order is
    *  unrecoverable client-side — a four-paragraph briefing rendered opening-paragraph-last
    *  (live 2026-08-10, D35). The API already orders by it; this lets a reader that
    *  re-sorts (grouping, filtering) put an arrival back in the order it was written. */
-  seq: z.number().int().optional(),
+  seq: z2.number().int().optional(),
   /** HOW MANY units the arrival was cut into. A device reads a LENS, never the arrival —
    *  `/api/inbox` serves `open`, so the units already settled are gone from it — and a client
    *  counting what it can see is counting what is LEFT. Walking a three-unit ask on the answer
@@ -2943,13 +4215,13 @@ var InboxItemSchema = z.object({
    *  server that can still see every row states it. Absent on any row with no `askId`: a
    *  unit knows WHICH ask it came from and WHERE it sat in it, and how many there were is
    *  the one part of its own arrival a single row cannot answer. */
-  units: z.number().int().positive().optional(),
-  tokenId: z.string().optional(),
+  units: z2.number().int().positive().optional(),
+  tokenId: z2.string().optional(),
   status: NotifyStatusSchema,
   context: ContextSchema,
-  options: z.array(OptionSchema).optional(),
+  options: z2.array(OptionSchema).optional(),
   /** The ask's declared coverage points (#396), when the agent sent them. */
-  points: z.array(z.string()).optional(),
+  points: z2.array(z2.string()).optional(),
   /** The call's AGENDA (broker/agenda-design.md): the ordered turns it is made of, built at
    *  ring/enqueue time. Replaces the condensed line + index-aligned phrased points, which
    *  between them could not express a call as a sequence. `question: null` is a real turn —
@@ -2958,12 +4230,12 @@ var InboxItemSchema = z.object({
    *  `requestAsks` — the agent's own declaration, not a guess. `false` is what earns a card
    *  its acknowledge affordance: without it a status update offers a text box and a dismiss,
    *  and neither of those is "got it" (owner, 2026-08-10). */
-  asks: z.boolean().optional(),
+  asks: z2.boolean().optional(),
   /** When a live process last pulsed for this row's agent — the liveness input for
    *  "working requires a pulse" (#928): the list said "Working…" from agent_state alone
    *  while the party called the same dead claim stalled. Absent = no token/no data,
    *  which must never CLAIM stalled. */
-  lastSeenAt: z.string().optional(),
+  lastSeenAt: z2.string().optional(),
   /** WHEN THE AGENT LAST SAID ANYTHING ABOUT THIS CLAIM — the newest `agent_state` row in
    *  the `notification_events` ledger (trigger-written since 20260621010000, so every row a
    *  user can see has one). The age input for `CLAIM_STALE_MS`, and it has to be this rather
@@ -2973,56 +4245,53 @@ var InboxItemSchema = z.object({
    *  work. Reading the row's birth as the claim's age brands that "No update in 8h" the
    *  instant the agent picks it up (#997). Absent = pre-trigger row; fall back to
    *  `createdAt`. */
-  agentStateAt: z.string().datetime().optional(),
-  agenda: z.array(AgendaTurnSchema).optional(),
-  /** On a replied detail (#397): the next steps the user attached to the answer
-   *  ("call back after lunch") — shown so they can see the commitment was captured. */
-  intents: z.array(IntentSchema).optional(),
-  visuals: z.array(VisualSchema).optional(),
+  agentStateAt: z2.string().datetime().optional(),
+  agenda: z2.array(AgendaTurnSchema).optional(),
+  visuals: z2.array(VisualSchema).optional(),
   /** The connected agent's name (the single pairing name — user-typed, or the
    *  agent's suggestion, or a default silly name). */
-  name: z.string(),
+  name: z2.string(),
   /** The pairing's assigned voice (#462); absent = the default voice. */
   voice: VoiceKeySchema.optional(),
-  repo: z.string().optional(),
-  branch: z.string().optional(),
-  createdAt: z.string().datetime(),
-  snoozedUntil: z.string().datetime().optional(),
+  repo: z2.string().optional(),
+  branch: z2.string().optional(),
+  createdAt: z2.string().datetime(),
+  snoozedUntil: z2.string().datetime().optional(),
   agentState: AgentStateSchema.default("idle"),
   /** Whose action the item is waiting on: "you" = an agent asked you (the default,
    *  every agent→user notification); "agent" = you sent a request and it's awaiting the
    *  agent (held in the inbox until the agent replies on the thread). */
-  turn: z.enum(["you", "agent"]).default("you"),
+  turn: z2.enum(["you", "agent"]).default("you"),
   /** Hard error reason on an awaiting request (turn="agent") — the wake failed to reach
    *  the agent (provider-agnostic; set server-side). Absent = no hard error, though the
    *  client may still flag a stall by age. Drives the inbox error badge + Retry. */
-  error: z.string().optional(),
-  clarifies: z.string().optional(),
+  error: z2.string().optional(),
+  clarifies: z2.string().optional(),
   /** The ring ladder ran out while this was still pending — we tried to reach you and
    *  STOPPED trying (`arbitration/arbitrate.ts` `nextRing` → `stop`). Distinct from an
    *  agent with nothing to say, which the roster drew identically until now: "nothing to
    *  say" and "gave up saying it" are opposite situations wearing the same face
    *  (navigation-design.md, gap 1). False for anything that never rang. */
-  gaveUp: z.boolean().default(false),
+  gaveUp: z2.boolean().default(false),
   /** Why this arrived the way it did, read back off the delivery receipt (`notify/why.ts`).
    *  Absent for anything never delivered through a push, and for older rows written before
    *  the reason was recorded. Deliberately a debug affordance, shown small (owner,
    *  2026-08-07) — its real job is to give "this didn't need a call" something to be
    *  feedback ABOUT. */
-  why: z.object({
+  why: z2.object({
     asked: NotifyLevelSchema,
     got: NotifyLevelSchema,
-    because: z.enum(["unresponsive", "dismissed", "not_permitted", "silent", "coalesced", "agent_capped", "unplanned", "learned_raise"]).optional(),
-    line: z.string()
+    because: z2.enum(["unresponsive", "dismissed", "not_permitted", "silent", "coalesced", "agent_capped", "unplanned", "learned_raise"]).optional(),
+    line: z2.string()
   }).optional(),
-  select: z.enum(["one", "many", "rank", "confirm", "text"]).default("one"),
-  confirmStyle: z.enum(["yesno", "approve"]).default("yesno").describe(
+  select: z2.enum(["one", "many", "rank", "confirm", "text"]).default("one"),
+  confirmStyle: z2.enum(["yesno", "approve"]).default("yesno").describe(
     "Labels for a select:'confirm' paige \u2014 'yesno' (Yes/No) or 'approve' (Approve/Deny). Ignored unless select is 'confirm'."
   ),
   /** Real downstream work is stuck behind this one — set by the agent, independent of
    *  urgency (see the main README's "premier use case" + notify/states.md). Drives the
    *  inbox's blocking badge and the extra confirm step before dismissing it. */
-  blocking: z.boolean().default(false),
+  blocking: z2.boolean().default(false),
   /** The user's locked-in answer; present only for replied items (GET /api/replied/:id). */
   answer: UserAnswerSchema.optional(),
   /** E2EE (text lane): the sealed content this item carries when the pairing is E2EE, in
@@ -3031,39 +4300,39 @@ var InboxItemSchema = z.object({
    *  NotifyRequest.envelope. The native app decrypts it locally via openNotification;
    *  web / an un-enrolled device can't and renders a locked placeholder. Absent = today's
    *  plaintext item (context carries the cleartext), so plaintext items are unchanged. */
-  envelope: z.object({
-    context: z.lazy(() => EnvelopeSchema).optional(),
-    options: z.lazy(() => EnvelopeSchema).optional(),
-    visuals: z.lazy(() => EnvelopeSchema).optional()
+  envelope: z2.object({
+    context: z2.lazy(() => EnvelopeSchema).optional(),
+    options: z2.lazy(() => EnvelopeSchema).optional(),
+    visuals: z2.lazy(() => EnvelopeSchema).optional()
   }).optional(),
   /** E2EE: the agent's device X25519 public key to seal the user's answer BACK to (the
    *  sender the phone replies to). Sourced server-side from this item's pairing credential.
    *  Present only alongside `envelope`; the phone seals via sealAnswer(answer, this, id). */
-  agentX25519: z.string().optional()
+  agentX25519: z2.string().optional()
 });
-var SnoozeRequestSchema = z.object({
-  requestId: z.string(),
-  until: z.string().datetime()
+var SnoozeRequestSchema = z2.object({
+  requestId: z2.string(),
+  until: z2.string().datetime()
 });
 var APNS_TOKEN_RE = /^[0-9a-fA-F]{64}$/;
-var PushTokenSchema = z.object({
-  voipToken: z.string().min(1).optional(),
-  alertToken: z.string().min(1).optional(),
-  fcmToken: z.string().min(1).optional(),
-  platform: z.enum(["ios", "android"])
+var PushTokenSchema = z2.object({
+  voipToken: z2.string().min(1).optional(),
+  alertToken: z2.string().min(1).optional(),
+  fcmToken: z2.string().min(1).optional(),
+  platform: z2.enum(["ios", "android"])
 }).superRefine((v, ctx) => {
   if (v.platform !== "ios") return;
   for (const field of ["voipToken", "alertToken"]) {
     const token = v[field];
     if (token === void 0 || APNS_TOKEN_RE.test(token)) continue;
     ctx.addIssue({
-      code: z.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       path: [field],
       message: `not an APNs device token (want 64 hex chars, got ${token.length})`
     });
   }
 });
-var MissedCallSchema = z.enum([
+var MissedCallSchema = z2.enum([
   "retry_10m",
   "retry_30m",
   "retry_60m",
@@ -3073,26 +4342,32 @@ var MissedCallSchema = z.enum([
   "inbox",
   "dismiss"
 ]);
-var BrokerTuningSchema = z.object({
+var BrokerTuningSchema = z2.object({
   /** 'none' = skip the spoken ack after a mapped answer (power users find it slow). */
-  ackVerbosity: z.enum(["normal", "none"]).optional(),
+  ackVerbosity: z2.enum(["normal", "none"]).optional(),
   /** How readily the mapper asks its one clarification: 'low' = only when truly
    *  uninterpretable, 'high' = whenever not fully certain. */
-  clarifyEagerness: z.enum(["low", "normal", "high"]).optional(),
+  clarifyEagerness: z2.enum(["low", "normal", "high"]).optional(),
   /** The user's own shorthand: when they say `say`, they mean `mean`. */
-  phrasebook: z.array(z.object({ say: z.string().min(1).max(60), mean: z.string().min(1).max(120) })).max(24).optional()
+  phrasebook: z2.array(z2.object({ say: z2.string().min(1).max(60), mean: z2.string().min(1).max(120) })).max(24).optional(),
+  /** The language calls are PLANNED in, when the account has chosen one (#1272). Absent —
+   *  which is every account today — means the agent's own words decide, per ask: a call
+   *  about an English ask opens in English. This is the only thing that overrides that,
+   *  and a live caller who switches language mid-call still outranks it (broker/lang.ts).
+   *  Set per user (no UI yet), like `voiceTuning`. */
+  language: z2.enum(["en", "es"]).optional()
 });
-var UserSettingsSchema = z.object({
-  permissions: z.object({
-    call: z.boolean(),
-    banner: z.boolean(),
-    push: z.boolean()
+var UserSettingsSchema = z2.object({
+  permissions: z2.object({
+    call: z2.boolean(),
+    banner: z2.boolean(),
+    push: z2.boolean()
   }),
-  sessionMode: z.enum(["default", "all_calls", "silent"]),
-  silentPush: z.boolean(),
-  autoCallback: z.boolean(),
+  sessionMode: z2.enum(["default", "all_calls", "silent"]),
+  silentPush: z2.boolean(),
+  autoCallback: z2.boolean(),
   /** Opt-in (default false) to using your content to improve Paigy and train models. */
-  improveConsent: z.boolean(),
+  improveConsent: z2.boolean(),
   missedCall: MissedCallSchema.default("backoff_standard"),
   /** Where voice audio is processed. 'hosted' (default) = Paigy's voice services
    *  (ElevenLabs TTS, faster-whisper STT, the call bot); 'on_device' = the phone
@@ -3100,7 +4375,7 @@ var UserSettingsSchema = z.object({
    *  Optional, NOT defaulted: a stale client PATCHing the full settings object
    *  must not silently reset this privacy choice. Absent = leave unchanged on
    *  write, 'hosted' on read (see store.ts). */
-  voiceMode: z.enum(["hosted", "on_device"]).optional(),
+  voiceMode: z2.enum(["hosted", "on_device"]).optional(),
   /** Per-user ring budget (#603): calls per rolling day before further calls
    *  degrade to banner. Absent = the global default (25). A number, never a
    *  bypass — every account keeps a ceiling. No UI; set per user for testing. */
@@ -3108,10 +4383,10 @@ var UserSettingsSchema = z.object({
    *  payload['tuning'] (e.g. { silence_s: 3.5 } — a longer pause window for a
    *  slower speaker). No API-side semantics; the bot resolves each key with its
    *  own defaults. Set per user (no UI yet); absent = bot defaults. */
-  voiceTuning: z.record(z.string(), z.union([z.number(), z.string()])).optional(),
+  voiceTuning: z2.record(z2.string(), z2.union([z2.number(), z2.string()])).optional(),
   /** Opt-in to real-phone (PSTN) calls when the app can't ring. Optional, not
    *  defaulted — an older client PATCHing the full object must not clobber it. */
-  pstnCalls: z.boolean().optional(),
+  pstnCalls: z2.boolean().optional(),
   /** The user's IANA timezone (e.g. "America/Bogota"), recorded by the app — it is the
    *  only party that knows it. REMINDERS are why it exists: "remind me at ten" becomes
    *  an absolute `due_at` only if we know whose ten. Optional and never defaulted, for
@@ -3120,50 +4395,50 @@ var UserSettingsSchema = z.object({
    *  that failure reads as the reminder rail being unreliable rather than as a missing
    *  setting. Absent = a spoken time can't be landed, so the reminder rides the next
    *  call — honest about what we know. */
-  timezone: z.string().min(1).max(64).optional(),
+  timezone: z2.string().min(1).max(64).optional(),
   /** Account E2EE state (text lane): 'off' (default) = today's plaintext; 'on' =
    *  content is sealed end-to-end between the local agent and the phone. Like
    *  voiceMode, OPTIONAL and NOT defaulted so a stale client PATCHing the full
    *  settings object without it can't silently flip the account's E2EE state.
    *  Absent = leave unchanged on write, 'off' on read (see store.ts). The demo
    *  account is plaintext by construction and refuses any non-'off' value. */
-  e2eeMode: z.enum(["off", "on"]).optional(),
+  e2eeMode: z2.enum(["off", "on"]).optional(),
   /** Rung-2 broker tuning (#381). Optional and NOT defaulted, same stale-client
    *  clobber guard as voiceMode: absent = leave unchanged on write. */
   broker: BrokerTuningSchema.optional()
 });
-var HistoryItemSchema = z.object({
-  id: z.string(),
-  parentId: z.string(),
+var HistoryItemSchema = z2.object({
+  id: z2.string(),
+  parentId: z2.string(),
   /** 'user' = a request you sent; 'agent' = a notification an agent sent you. */
-  initiator: z.enum(["user", "agent"]),
-  title: z.string(),
+  initiator: z2.enum(["user", "agent"]),
+  title: z2.string(),
   /** The agent on the other end (its name). */
-  name: z.string(),
-  createdAt: z.string(),
+  name: z2.string(),
+  createdAt: z2.string(),
   /** When the agent fetched your request (user→agent only). */
-  agentAckedAt: z.string().nullable(),
+  agentAckedAt: z2.string().nullable(),
   /** When you answered the agent's notification (agent→user only). */
-  humanAckedAt: z.string().nullable()
+  humanAckedAt: z2.string().nullable()
 });
 var ACTIVITY_LINES = 2;
 var ACTIVITY_LINE_MAX = 80;
-var AgentActivitySchema = z.object({
+var AgentActivitySchema = z2.object({
   /** Oldest first, so the newest line is last — the one that replaces in place. */
-  lines: z.array(z.string().max(ACTIVITY_LINE_MAX)).max(ACTIVITY_LINES),
+  lines: z2.array(z2.string().max(ACTIVITY_LINE_MAX)).max(ACTIVITY_LINES),
   /** When the harness observed this tail. Its own timestamp, not the heartbeat's: a beat
    *  that carries an UNCHANGED tail must not make a stalled agent look like it just moved. */
-  at: z.string().datetime()
+  at: z2.string().datetime()
 });
-var ConnectionSummarySchema = z.object({
+var ConnectionSummarySchema = z2.object({
   /** The connection = the agent's token id (used to address a request). */
-  id: z.string(),
-  device: z.string().nullable(),
+  id: z2.string(),
+  device: z2.string().nullable(),
   /** The agent's display name (the single pairing name). */
-  name: z.string(),
+  name: z2.string(),
   /** For a managed connection, the provider key (e.g. "cma") that agentOrigin maps to a
    *  label; null for a local connection. Sourced from the token's provider, not the name. */
-  provider: z.string().nullable(),
+  provider: z2.string().nullable(),
   /** The pairing's assigned voice (#462); null = the default voice. */
   voice: VoiceKeySchema.nullable(),
   /** The LOUDEST this agent may ever reach you — a ceiling on `NOTIFY_LADDER`, set by the
@@ -3174,19 +4449,19 @@ var ConnectionSummarySchema = z.object({
    *  every surface at once and outranks even `sessionMode: all_calls` — a mode the user
    *  set once must not overrule a rule they set about one agent. */
   reach: NotifyLevelSchema.nullable().optional(),
-  createdAt: z.string().datetime(),
+  createdAt: z2.string().datetime(),
   /** Most recent notification on this connection, either direction. Null = no contact yet.
    *  Drives the agents-page recency grouping (Today / This week / …). */
-  lastContactAt: z.string().datetime().nullable(),
+  lastContactAt: z2.string().datetime().nullable(),
   /** Last presence heartbeat from a running agent process (POST /api/presence) — the
    *  desktop app while open. Null = never seen; stale = offline. */
-  lastSeenAt: z.string().datetime().nullable().optional(),
+  lastSeenAt: z2.string().datetime().nullable().optional(),
   /** What a live desktop can run (companion.md §2.2), advertised on its heartbeat:
    *  harness availabilities + granted workspaces — the option set the phone's
    *  "new session" sheet offers. Absent for ordinary MCP agents. */
-  runtime: z.object({
-    harnesses: z.array(z.object({ name: z.string(), label: z.string(), status: z.string() })).optional(),
-    workspaces: z.array(z.string()).optional()
+  runtime: z2.object({
+    harnesses: z2.array(z2.object({ name: z2.string(), label: z2.string(), status: z2.string() })).optional(),
+    workspaces: z2.array(z2.string()).optional()
   }).optional(),
   /** The tail of this agent's working log, when a harness is driving it — the agent page's
    *  live strip. Absent for anything the desktop harness isn't running (a hatched identity
@@ -3195,245 +4470,305 @@ var ConnectionSummarySchema = z.object({
   activity: AgentActivitySchema.optional(),
   /** True = a provider-managed agent running in the provider's cloud (e.g. Anthropic CMA);
    *  false = a local MCP connection running on the user's computer (Claude Code/Codex/…). */
-  managed: z.boolean()
+  managed: z2.boolean()
 });
-var MoveRingSchema = z.enum(["home", "travels", "retired", "quarantined"]);
-var MoveSchema = z.object({
-  id: z.string(),
+var MoveRingSchema = z2.enum(["home", "travels", "retired", "quarantined"]);
+var MoveSchema = z2.object({
+  id: z2.string(),
   /** The reusable question, as distill normalized it. */
-  question: z.string(),
+  question: z2.string(),
   /** The operative ruling. Editable by the user (PATCH) — which resets the ledger. */
-  answer: z.string(),
+  answer: z2.string(),
   /** The user's stated reason, when they gave one. Null = inherently narrow: the judge is
    *  told so, and the ruling only derives essentially the same question in the same scope. */
-  rationale: z.string().nullable(),
+  rationale: z2.string().nullable(),
   /** Where the ruling lives: a repo/workspace, or 'global'. */
-  scope: z.string(),
+  scope: z2.string(),
   ring: MoveRingSchema,
   /** True = the user pinned it with `always` (travel granted by hand, not by evidence). */
-  pinned: z.boolean(),
+  pinned: z2.boolean(),
   /** True = a pin the user placed was BROKEN by later counter-evidence. Surfaced so the
    *  break is visible instead of a pin silently disappearing. */
-  pinBroken: z.boolean(),
+  pinBroken: z2.boolean(),
   /** When the ruling was distilled. */
-  learnedAt: z.string(),
+  learnedAt: z2.string(),
   /** Last time it answered an ask. Null = never fired. */
-  lastUsedAt: z.string().nullable(),
+  lastUsedAt: z2.string().nullable(),
   /** How many asks it has answered. Instrumentation — deliberately NOT an input to the
    *  evidence curve: firing says the question keeps arising, not that the ruling is right. */
-  usedCount: z.number(),
+  usedCount: z2.number(),
   /** Ledger: outcomes that said it held up. Saturating — the tenth is worth almost nothing. */
-  confirms: z.number(),
+  confirms: z2.number(),
   /** Ledger: contradictions, in signal units (a full override = 1, weaker signals less).
    *  Linear and priced above the entire confirmation budget, so any full counter wins. */
-  counters: z.number(),
+  counters: z2.number(),
   /** The agent that asked the question this move came from, when known. Null for a move
    *  distilled from a clarify ruling (those carry no agent) or one whose source rows are gone. */
-  learnedFrom: z.object({ id: z.string(), name: z.string() }).nullable()
+  learnedFrom: z2.object({ id: z2.string(), name: z2.string() }).nullable()
 });
-var CreateRequestSchema = z.object({
+var CreateRequestSchema = z2.object({
   /** The connection (token id) to send to, from GET /api/tokens. */
-  tokenId: z.string(),
+  tokenId: z2.string(),
   /** The user's message to the agent. */
-  text: z.string().min(1),
+  text: z2.string().min(1),
   /** Land the request on an existing conversation thread (History → "Continue")
    *  instead of minting a fresh one. Must belong to the requesting user. */
-  parentId: z.string().optional(),
+  parentId: z2.string().optional(),
   /** Point the agent at a past conversation (possibly with a different agent) as
    *  starting context (History → "New session from this"). A reference, not a copy —
    *  the agent reads it via get_thread. Must belong to the requesting user. */
-  contextParentId: z.string().optional()
+  contextParentId: z2.string().optional()
 });
-var HandoffSchema = z.object({
+var HandoffSchema = z2.object({
+  /** Move this existing outcome to `target` without reminting it. Requires `target`. */
+  workId: z2.string().uuid().optional(),
   /** Land the note on an existing thread; omitted mints a fresh one. */
-  parentId: z.string().uuid().optional(),
+  parentId: z2.string().uuid().optional(),
   /** One-line headline of the working context handed off. */
-  title: z.string().min(1),
+  title: z2.string().min(1),
   /** The brief — standalone notes the successor reads (what was done, what's left, links). */
-  notes: z.array(z.string().min(1)).min(1),
+  notes: z2.array(z2.string().min(1)).min(1),
   /** A sibling connection to dispatch directly to (token id or agent nickname). Same-account
    *  only; omit to leave the thread for the user to hand off in the app. */
-  target: z.string().optional(),
+  target: z2.string().optional(),
   /** Write the note as a RECAP (kind:'recap', #617): a summary turn that supersedes the
    *  thread's earlier turns for rehydration — get_thread returns the latest recap + only
    *  the turns after it. Handoff-to-a-successor and handoff-to-yourself-later are the
    *  same primitive; a recap is one whose audience includes you. */
-  recap: z.boolean().optional()
+  recap: z2.boolean().optional()
+}).refine((value) => !value.workId || Boolean(value.target), {
+  message: "target is required when handing off Work",
+  path: ["target"]
 });
-var NoteSourceSchema = z.enum(["app", "call"]);
-var NoteStatusSchema = z.enum(["open", "assigned", "in_progress", "done"]);
-var NoteRepeatSchema = z.enum(["once", "until_done"]);
-var DecisionSchema = z.object({
-  id: z.string(),
+var NoteSourceSchema = z2.enum(["app", "call"]);
+var NoteStatusSchema = z2.enum(["open", "assigned", "in_progress", "done"]);
+var NoteRepeatSchema = z2.enum(["once", "until_done"]);
+var DecisionSchema = z2.object({
+  id: z2.string(),
   /** The note this decision refines; null = recorded on a bare thread (the
    *  extensibility seam — any conversation can accrue decisions). */
-  noteId: z.string().nullable(),
+  noteId: z2.string().nullable(),
   /** What was ambiguous — the broker's (or the user's own) question. */
-  question: z.string(),
+  question: z2.string(),
   /** The user's ruling; null while the question is open. */
-  answer: z.string().nullable(),
-  decidedAt: z.string().nullable(),
-  createdAt: z.string()
+  answer: z2.string().nullable(),
+  decidedAt: z2.string().nullable(),
+  createdAt: z2.string()
 });
-var NoteSchema = z.object({
-  id: z.string(),
+var NoteSchema = z2.object({
+  id: z2.string(),
   /** One-line headline (broker-titled; deterministic floor). */
-  title: z.string(),
+  title: z2.string(),
   /** The original intent, verbatim — assignees always see the user's own words. */
-  intent: z.string(),
+  intent: z2.string(),
   source: NoteSourceSchema,
   status: NoteStatusSchema,
   /** Who it was assigned to (a participant ref, 'agent:<tokenId>'); null = unassigned. */
-  assignee: z.string().nullable(),
+  assignee: z2.string().nullable(),
   /** The request thread minted at assignment; null until assigned. */
-  parentId: z.string().nullable(),
+  parentId: z2.string().nullable(),
   /** REMINDERS (reminders-design.md): the NOT-BEFORE this becomes eligible to ride a
-   *  call — never a deadline, and nothing rings when it passes. Null = "the very next
+   *  call — never a deadline. It only ever comes from the user's own words, so when it
+   *  passes Paigy rings ONCE (#1293, owner 2026-08-26: a time said out loud is consent to
+   *  a ring at that time); after that it rides like any other. Null = "the very next
    *  call", the right reading of "remind me to…" with no time attached. */
   //  Defaulted, not required: a Note from an API deploy older than the reminders
   //  migration has none of these, and the defaults ARE what it means — no not-before,
   //  one ride, never ridden. Parsing must not fail across a rolling deploy.
-  dueAt: z.string().nullable().default(null),
+  dueAt: z2.string().nullable().default(null),
   repeat: NoteRepeatSchema.default("once"),
   /** How many calls have already carried it — the fatigue cap counts rides, not days. */
-  rides: z.number().int().default(0),
-  lastRideAt: z.string().nullable().default(null),
-  createdAt: z.string()
+  rides: z2.number().int().default(0),
+  lastRideAt: z2.string().nullable().default(null),
+  createdAt: z2.string()
 });
-var CreateNoteSchema = z.object({
+var CreateNoteSchema = z2.object({
   /** The intent, in the user's own words. Stored verbatim; the broker only titles it. */
-  text: z.string().min(1).max(4e3),
+  text: z2.string().min(1).max(4e3),
   /** Capture it as a REMINDER — a note assigned to the user themselves, which rides
    *  their next call instead of being handed to an agent. Everything else about the
    *  note is identical; this is the one parameter that separates the two. */
-  forMe: z.boolean().optional(),
+  forMe: z2.boolean().optional(),
   /** The not-before, when the user already said one. Absent = the very next call. */
-  dueAt: z.string().datetime().optional(),
+  dueAt: z2.string().datetime().optional(),
   repeat: NoteRepeatSchema.optional()
 });
-var RecordDecisionSchema = z.object({
+var RecordDecisionSchema = z2.object({
   /** An open decision (from /clarify) to answer. */
-  decisionId: z.string().optional(),
+  decisionId: z2.string().optional(),
   /** For an ad-hoc decision: what was ambiguous. Required without `decisionId`. */
-  question: z.string().min(1).max(500).optional(),
+  question: z2.string().min(1).max(500).optional(),
   /** The ruling. */
-  answer: z.string().min(1).max(2e3)
+  answer: z2.string().min(1).max(2e3)
 }).refine((d) => d.decisionId || d.question, { message: "decisionId or question required" });
-var AssignNoteSchema = z.object({
+var AssignNoteSchema = z2.object({
   /** An EXISTING agent: token id or nickname. Omit when spawning fresh. */
-  target: z.string().min(1).optional(),
+  target: z2.string().min(1).optional(),
   /** Spawn a NEW session for this note (companion.md §2.2): the assignee doesn't
    *  exist yet — mint it on a live desktop that advertises the harness+workspace,
    *  named after the note. The brief arrives as its opening request. */
-  spawn: z.object({
-    hostTokenId: z.string().uuid(),
-    harness: z.string().min(1),
-    workspace: z.string().min(1)
+  spawn: z2.object({
+    hostTokenId: z2.string().uuid(),
+    harness: z2.string().min(1),
+    workspace: z2.string().min(1)
   }).optional()
 }).refine((a) => !!a.target !== !!a.spawn, { message: "exactly one of target or spawn" });
-var DeliveryModeSchema = z.enum(["poll", "self_hosted"]);
-var RegisterDeliverySchema = z.object({ mode: DeliveryModeSchema });
-var OAuthStartSchema = z.object({
-  provider: z.enum(["cma"]),
-  returnTo: z.string().min(1)
+var TriageVerdictSchema = z2.enum(["keep", "stale", "close", "assign"]);
+var TriageItemSchema = z2.object({
+  noteId: z2.string(),
+  /** The note's headline at run time. */
+  title: z2.string(),
+  /** WHY, in one short human line, evidence first — this is read on a phone underneath
+   *  the note's title: "no movement in 34 days", "worked 3 notes in this repo this week".
+   *  Never a model's reasoning transcript, never an id. */
+  why: z2.string()
+});
+var TriageAssignmentSchema = z2.object({
+  /** The agent's token id — what `dispatchNote` resolves and what a request is addressed to. */
+  agent: z2.string(),
+  /** Its display name at run time (the name on the hatchling's card). Denormalized for the
+   *  same reason as `title`: the card must render from the proposal alone. */
+  agentName: z2.string(),
+  notes: z2.array(TriageItemSchema)
+});
+var TriageStatusSchema = z2.enum(["open", "superseded", "dismissed"]);
+var SubmitTriageSchema = z2.object({
+  /** Which runtime judged: "ollama" (inference never left the machine) or a harness the
+   *  user already runs under their own credentials ("claude" / "codex" / "agy"). Recorded
+   *  so the phone can say where the content went — an unattributed privacy claim is worth
+   *  nothing, and #1106's promise is precisely "Paigy's servers never see this". */
+  provider: z2.string().min(1).max(60),
+  /** The concrete model when the provider names one (an ollama tag); null otherwise. */
+  model: z2.string().max(200).nullable().optional(),
+  /** How many open notes the run actually looked at — the denominator on the phone
+   *  ("6 of 50"), and the honest answer to "did it read the whole queue?". */
+  reviewed: z2.number().int().min(0).max(1e4).default(0),
+  close: z2.array(TriageItemSchema).max(200).default([]),
+  stale: z2.array(TriageItemSchema).max(200).default([]),
+  assign: z2.array(TriageAssignmentSchema).max(50).default([])
 });
-var DeliveryConfigSchema = z.object({
-  tokenId: z.string(),
+var TriageProposalSchema = SubmitTriageSchema.extend({
+  id: z2.string(),
+  runAt: z2.string(),
+  status: TriageStatusSchema,
+  model: z2.string().nullable().default(null)
+});
+var AcceptTriageSchema = z2.discriminatedUnion("group", [
+  z2.object({ group: z2.literal("close"), noteIds: z2.array(z2.string()).max(200).optional() }),
+  z2.object({ group: z2.literal("stale"), noteIds: z2.array(z2.string()).max(200).optional() }),
+  z2.object({
+    group: z2.literal("assign"),
+    agent: z2.string().min(1),
+    noteIds: z2.array(z2.string()).max(200).optional()
+  })
+]);
+var AcceptTriageResultSchema = z2.object({
+  accepted: z2.array(z2.string()),
+  failed: z2.array(z2.object({ noteId: z2.string(), reason: z2.string() }))
+});
+var DeliveryModeSchema = z2.enum(["poll", "self_hosted"]);
+var RegisterDeliverySchema = z2.object({ mode: DeliveryModeSchema });
+var OAuthStartSchema = z2.object({
+  provider: z2.enum(["cma"]),
+  returnTo: z2.string().min(1)
+});
+var DeliveryConfigSchema = z2.object({
+  tokenId: z2.string(),
   mode: DeliveryModeSchema,
   /** null when the server has no SUPABASE_ANON_KEY set — the listener then falls
    *  back to its own PAIGY_SUPABASE_URL / PAIGY_SUPABASE_ANON_KEY env. */
-  realtime: z.object({ url: z.string(), anonKey: z.string() }).nullable()
+  realtime: z2.object({ url: z2.string(), anonKey: z2.string() }).nullable()
 });
-var StatusSchema = z.object({
-  name: z.string(),
-  sessionMode: z.enum(["default", "all_calls", "silent"]),
+var StatusSchema = z2.object({
+  name: z2.string(),
+  sessionMode: z2.enum(["default", "all_calls", "silent"]),
   /** A phone is registered for push/ring (any push token on the account). */
-  phone: z.boolean()
+  phone: z2.boolean()
 });
-var EnvelopeRecipientSchema = z.object({
-  keyId: z.string(),
-  epk: z.string(),
-  wnonce: z.string(),
-  wrap: z.string()
+var EnvelopeRecipientSchema = z2.object({
+  keyId: z2.string(),
+  epk: z2.string(),
+  wnonce: z2.string(),
+  wrap: z2.string()
 });
-var EnvelopeHeaderSchema = z.object({
-  field: z.enum(["context", "options", "visuals", "answer"]),
-  kind: z.string(),
-  senderRole: z.enum(["agent", "user"]),
-  recipientKeyIds: z.array(z.string()),
-  seq: z.number().int().nonnegative()
+var EnvelopeHeaderSchema = z2.object({
+  field: z2.enum(["context", "options", "visuals", "answer"]),
+  kind: z2.string(),
+  senderRole: z2.enum(["agent", "user"]),
+  recipientKeyIds: z2.array(z2.string()),
+  seq: z2.number().int().nonnegative()
 });
-var EnvelopeSchema = z.object({
-  v: z.literal(1),
-  alg: z.literal("x25519-xsalsa20poly1305"),
-  msgId: z.string(),
+var EnvelopeSchema = z2.object({
+  v: z2.literal(1),
+  alg: z2.literal("x25519-xsalsa20poly1305"),
+  msgId: z2.string(),
   hdr: EnvelopeHeaderSchema,
-  recipients: z.array(EnvelopeRecipientSchema).min(1),
-  nonce: z.string(),
-  ct: z.string()
+  recipients: z2.array(EnvelopeRecipientSchema).min(1),
+  nonce: z2.string(),
+  ct: z2.string()
 });
-var SealedAnswerSchema = z.object({
-  ignored: z.boolean(),
+var SealedAnswerSchema = z2.object({
+  ignored: z2.boolean(),
   envelope: EnvelopeSchema
 });
-var DeviceCredentialSchema = z.object({
-  deviceId: z.string(),
-  kind: z.enum(["phone", "web", "agent"]),
-  x25519Pub: z.string(),
-  ed25519Pub: z.string(),
-  sig: z.string()
+var DeviceCredentialSchema = z2.object({
+  deviceId: z2.string(),
+  kind: z2.enum(["phone", "web", "agent"]),
+  x25519Pub: z2.string(),
+  ed25519Pub: z2.string(),
+  sig: z2.string()
 });
-var DeviceRosterSchema = z.object({
-  uikPub: z.string(),
-  devices: z.array(DeviceCredentialSchema)
+var DeviceRosterSchema = z2.object({
+  uikPub: z2.string(),
+  devices: z2.array(DeviceCredentialSchema)
 });
-var WakeNudgeSchema = z.object({
-  kind: z.enum(["reply", "request", "callback"]),
-  notificationId: z.string().optional(),
-  parentId: z.string()
+var WakeNudgeSchema = z2.object({
+  kind: z2.enum(["reply", "request", "callback"]),
+  notificationId: z2.string().optional(),
+  parentId: z2.string()
 });
-var PairingStatusSchema = z.enum(["pending", "approved", "denied", "expired"]);
-var PairingRevealSchema = z.object({
-  x25519: z.string(),
-  ed25519: z.string(),
-  nonce: z.string()
+var PairingStatusSchema = z2.enum(["pending", "approved", "denied", "expired"]);
+var PairingRevealSchema = z2.object({
+  x25519: z2.string(),
+  ed25519: z2.string(),
+  nonce: z2.string()
 });
-var DeviceCodeRequestSchema = z.object({
+var DeviceCodeRequestSchema = z2.object({
   /** The agent's suggested name for the pairing — the human sees it pre-filled at
    *  approval and can override. Optional; blank → a default silly name server-side. */
-  suggestedName: z.string().optional(),
+  suggestedName: z2.string().optional(),
   /** Legacy alias for suggestedName (older MCPs sent `agent`). Accepted for
    *  back-compat; `suggestedName` wins when both are present. ponytail: drop once no
    *  pre-`name` MCP is in the wild. */
-  agent: z.union([z.string(), z.object({ name: z.string().optional() })]).optional(),
-  device: z.string().optional(),
-  proto: z.string().optional(),
+  agent: z2.union([z2.string(), z2.object({ name: z2.string().optional() })]).optional(),
+  device: z2.string().optional(),
+  proto: z2.string().optional(),
   // compiled-in tag, e.g. "paigy-pair-v2|sas=24"
-  commitment: z.string().optional()
+  commitment: z2.string().optional()
   // agent's Ca
 });
-var DeviceCodeSchema = z.object({
-  device_code: z.string(),
-  user_code: z.string(),
-  verification_uri: z.string().url(),
-  verification_uri_complete: z.string().url(),
-  interval: z.number(),
-  expires_in: z.number()
+var DeviceCodeSchema = z2.object({
+  device_code: z2.string(),
+  user_code: z2.string(),
+  verification_uri: z2.string().url(),
+  verification_uri_complete: z2.string().url(),
+  interval: z2.number(),
+  expires_in: z2.number()
 });
-var DeviceInfoSchema = z.object({
-  code: z.string(),
+var DeviceInfoSchema = z2.object({
+  code: z2.string(),
   /** The agent's suggested name (from /device/code) — shown on the approval screen,
    *  pre-filling the name field the human can edit. */
-  name: z.string(),
+  name: z2.string(),
   /** @deprecated Legacy alias of `name` for the pre-#531 embedded bundle in App Store
    *  build 35, whose DeviceFlow renders `info.agent.slice(0, 2)` — without this a FRESH
    *  install crashes on the pairing screen on first launch, before the OTA lands
    *  (seen live: PAIGY-5T, 2026-07-21). Remove once a newer binary is the floor. */
-  agent: z.string().optional(),
-  device: z.string().nullable(),
+  agent: z2.string().optional(),
+  device: z2.string().nullable(),
   status: PairingStatusSchema,
-  proto: z.string().nullable().optional(),
-  agent_commitment: z.string().nullable().optional(),
+  proto: z2.string().nullable().optional(),
+  agent_commitment: z2.string().nullable().optional(),
   // Ca
   agent_reveal: PairingRevealSchema.nullable().optional(),
   // present once the agent reveals
@@ -3443,48 +4778,48 @@ var DeviceInfoSchema = z.object({
   // withheld until e2ee=true) can compute the SAS WITHOUT a token. Public keys — same safety
   // class as agent_reveal above. Present only once the phone reveals; null otherwise.
   phone_reveal: PairingRevealSchema.nullable().optional(),
-  uik_pub: z.string().nullable().optional()
+  uik_pub: z2.string().nullable().optional()
 });
-var DeviceTokenRequestSchema = z.object({
-  device_code: z.string(),
+var DeviceTokenRequestSchema = z2.object({
+  device_code: z2.string(),
   reveal: PairingRevealSchema.optional()
   // agent's reveal {x25519, ed25519, nonce}
 });
-var DeviceTokenSchema = z.object({
-  access_token: z.string(),
+var DeviceTokenSchema = z2.object({
+  access_token: z2.string(),
   /** The pairing's single name (user-typed at approval, the agent's suggestion, or
    *  a default silly name). */
-  name: z.string(),
-  device: z.string().nullable(),
+  name: z2.string(),
+  device: z2.string().nullable(),
   /** The pairing's assigned voice, cached so the desktop can seed the SAME face the phone
    *  draws — voice is the third ingredient of a hatchling's build (party/traits.ts). */
-  voice: z.string().nullable().optional(),
+  voice: z2.string().nullable().optional(),
   /** The token's server-side id — the face's COLOUR anchor, and the only seed ingredient
    *  that survives a rename. Cached by the host's identity beat. */
-  token_id: z.string().nullable().optional(),
+  token_id: z2.string().nullable().optional(),
   /** WHERE this identity works — the folder a wake should land it in. Written by the host
    *  at spawn and by `paigy-harness handoff` from a live terminal. Without it every wake
    *  landed in the FIRST granted workspace and the agent rediscovered its own repo from
    *  the thread each time (host.ts, live catch 2026-08-06 — prompt-papered until now). */
-  workspace: z.string().nullable().optional(),
+  workspace: z2.string().nullable().optional(),
   phone_reveal: PairingRevealSchema.nullable().optional(),
   // present once the phone reveals
-  uik_pub: z.string().nullable().optional()
+  uik_pub: z2.string().nullable().optional()
 });
-var DeviceCommitRequestSchema = z.object({
-  code: z.string(),
-  commitment: z.string()
+var DeviceCommitRequestSchema = z2.object({
+  code: z2.string(),
+  commitment: z2.string()
   // Cb
 });
-var DevicePeerCommitSchema = z.object({
-  commitment: z.string().nullable()
+var DevicePeerCommitSchema = z2.object({
+  commitment: z2.string().nullable()
 });
-var SupportRequestSchema = z.object({
-  email: z.string().email().max(320),
-  message: z.string().trim().min(1).max(5e3),
-  name: z.string().trim().max(120).optional()
+var SupportRequestSchema = z2.object({
+  email: z2.string().email().max(320),
+  message: z2.string().trim().min(1).max(5e3),
+  name: z2.string().trim().max(120).optional()
 });
-var NotificationFeedbackKindSchema = z.enum([
+var NotificationFeedbackKindSchema = z2.enum([
   "break_down",
   // "This should be more than one ask — break it down."
   "regenerate_options",
@@ -3498,76 +4833,30 @@ var NotificationFeedbackKindSchema = z.enum([
   "other"
   // anything else — the note carries it.
 ]);
-var NotificationFeedbackSchema = z.object({
-  notificationId: z.string(),
+var NotificationFeedbackSchema = z2.object({
+  notificationId: z2.string(),
   kind: NotificationFeedbackKindSchema,
   /** Optional free-text elaboration for a preset; required (non-empty) for 'other'. */
-  note: z.string().trim().max(2e3).optional()
+  note: z2.string().trim().max(2e3).optional()
 }).superRefine((r, ctx) => {
   if (r.kind === "other" && !r.note)
-    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["note"], message: "note is required for 'other' feedback" });
+    ctx.addIssue({ code: z2.ZodIssueCode.custom, path: ["note"], message: "note is required for 'other' feedback" });
 });
-var FeedbackResolutionSchema = z.enum(["broker_fixed", "sent_to_agent"]);
-var FeedbackOutcomeSchema = z.object({
+var FeedbackResolutionSchema = z2.enum(["broker_fixed", "sent_to_agent"]);
+var FeedbackOutcomeSchema = z2.object({
   resolution: FeedbackResolutionSchema,
   transform: TransformSchema,
-  message: z.string(),
-  childIds: z.array(z.string()).optional()
+  message: z2.string(),
+  childIds: z2.array(z2.string()).optional()
+});
+var CONTACT_SCHEMA = contactSchemaFrom({
+  ask: NotifyRequestFields.shape.ask,
+  waiting: NotifyRequestFields.shape.waiting,
+  options: NotifyRequestFields.shape.options,
+  channel: NotifyRequestFields.shape.channel,
+  parentId: NotifyRequestFields.shape.parentId,
+  workId: NotifyRequestFields.shape.workId
 });
-var WORD_NUMS = {
-  a: 1,
-  an: 1,
-  one: 1,
-  two: 2,
-  three: 3,
-  four: 4,
-  five: 5,
-  six: 6,
-  seven: 7,
-  eight: 8,
-  nine: 9,
-  ten: 10,
-  fifteen: 15,
-  twenty: 20,
-  thirty: 30,
-  forty: 40,
-  "forty-five": 45,
-  fifty: 50,
-  sixty: 60,
-  "half an": 0.5,
-  "a couple of": 2,
-  "a few": 3
-};
-function untilHour(hour, now) {
-  const due = new Date(now);
-  due.setHours(hour, 0, 0, 0);
-  if (due.getTime() <= now.getTime()) due.setDate(due.getDate() + 1);
-  return Math.round((due.getTime() - now.getTime()) / 1e3);
-}
-function parseDue(detail, now = /* @__PURE__ */ new Date()) {
-  const t = detail.toLowerCase().trim();
-  const rel = /(?:^|\b)in\s+(half an|a couple of|a few|an?|[\w-]+|\d+)\s*(minutes?|mins?|hours?|hrs?)\b/.exec(t);
-  if (rel) {
-    const n = /^\d+$/.test(rel[1]) ? Number(rel[1]) : WORD_NUMS[rel[1]];
-    if (n !== void 0) {
-      const unit = rel[2].startsWith("h") ? 3600 : 60;
-      return Math.round(n * unit);
-    }
-  }
-  if (/after lunch|lunchtime/.test(t)) return untilHour(13, now);
-  if (/tomorrow/.test(t)) {
-    const due = new Date(now);
-    due.setDate(due.getDate() + 1);
-    due.setHours(9, 0, 0, 0);
-    return Math.round((due.getTime() - now.getTime()) / 1e3);
-  }
-  if (/tonight|this evening/.test(t)) {
-    return now.getHours() < 20 ? untilHour(20, now) : 3600;
-  }
-  if (/end of (the )?day|eod/.test(t)) return untilHour(17, now);
-  if (/later|in a (bit|while)/.test(t)) return 1800;
-  return null;
-}
 var import_tweetnacl = __toESM(require_nacl_fast(), 1);
 var import_tweetnacl2 = __toESM(require_nacl_fast(), 1);
 var import_tweetnacl3 = __toESM(require_nacl_fast(), 1);
@@ -3836,10 +5125,32 @@ function verifyPairingCommit(commitment, proto, role, x25519Pub, ed25519Pub, non
     return false;
   }
 }
-function sessionSlot(sessionId) {
-  const id = sessionId ?? process.env.PAIGY_SESSION_ID ?? process.env.CLAUDE_CODE_SESSION_ID ?? randomUUID2();
+function sessionSlot(sessionId2) {
+  const id = sessionId2 ?? sessionId();
   return `session:${id.slice(0, 8)}`;
 }
+function subagentId(env = process.env) {
+  if (!env.CLAUDE_CODE_CHILD_SESSION) return null;
+  const pid = env.CLAUDE_PID ?? env.CLAUDE_CODE_MESSAGING_SOCKET?.match(/(\d+)\.sock$/)?.[1];
+  return pid ?? null;
+}
+function subagentThread(env = process.env, sessionId2) {
+  const base = sessionId2 ?? sessionId();
+  const sub = subagentId(env);
+  return sub ? `${base}:sub:${sub}` : base;
+}
+function uuidFromKey(key) {
+  const h = createHash("sha1").update(`paigy-thread:${key}`).digest();
+  h[6] = h[6] & 15 | 80;
+  h[8] = h[8] & 63 | 128;
+  const hex = h.subarray(0, 16).toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function contactParentId(explicit, env = process.env) {
+  if (explicit) return explicit;
+  if (!subagentId(env)) return void 0;
+  return uuidFromKey(subagentThread(env));
+}
 var AGENT_NAME = process.env.PAIGY_AGENT || sessionSlot();
 var PROTO = "paigy-pair-v2|sas=24";
 var SAS_BITS = 24;
@@ -3911,13 +5222,15 @@ async function revokeToken(token) {
   });
   return res.ok;
 }
-async function requestCode(suggestedName = AGENT_NAME, e2ee) {
+async function requestCode(suggestedName = AGENT_NAME, e2ee, device) {
   const res = await reach(`${BACKEND_URL}/api/device/code`, {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify(
-      e2ee ? { suggestedName, proto: e2ee.proto, commitment: e2ee.commitment } : { suggestedName }
-    )
+    body: JSON.stringify({
+      suggestedName,
+      ...device ? { device } : {},
+      ...e2ee ? { proto: e2ee.proto, commitment: e2ee.commitment } : {}
+    })
   });
   if (!res.ok) throw new Error(`/api/device/code failed: ${res.status} ${await res.text()}`);
   return await res.json();
@@ -4101,6 +5414,16 @@ async function sealForE2ee(req, token, deps = {}) {
   const { context: _c, options: _o, visuals: _v, repo: _r, branch: _b, ...meta } = req;
   return { ...meta, envelope };
 }
+async function createGoal(input, opts = {}) {
+  const token = authToken(opts.token) ?? "";
+  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/goals`, {
+    method: "POST",
+    headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+    body: JSON.stringify(input)
+  }));
+  if (!res.ok) throw new Error(`create_goal failed: ${res.status} ${await res.text()}`);
+  return await res.json();
+}
 async function submitNotification(req, opts = {}) {
   const token = authToken(opts.token) ?? "";
   const body = await sealForE2ee(req, token);
@@ -4113,27 +5436,10 @@ async function submitNotification(req, opts = {}) {
   return await res.json();
 }
 var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
-function decryptAnswer(reply, deps = {}) {
-  if (!reply.sealed) return reply.answer;
-  const keyFile = (deps.readKeyFile ?? readKeyFile)();
-  if (!keyFile?.keypair) {
-    throw new Error("received a sealed answer but this agent has no device key to open it \u2014 re-pair.");
-  }
-  return openSealedAnswer(reply.sealed, keyFile.keypair);
-}
-async function pollAnswer(notificationId) {
-  const token = readToken();
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/await?notificationId=${encodeURIComponent(notificationId)}`, {
-    headers: { authorization: `Bearer ${token}` }
-  }));
-  if (!res.ok) throw new Error(`await failed: ${res.status} ${await res.text()}`);
-  const item = await res.json();
-  return item.type === "idle" ? item : decryptItem(item);
-}
 var AWAIT_WINDOW_MS = 45e3;
 var _partialSeen = /* @__PURE__ */ new Map();
 async function pollPartials(notificationId) {
-  const token = readToken();
+  const token = authToken();
   const after = _partialSeen.get(notificationId) ?? 0;
   try {
     const res = await reach(
@@ -4150,38 +5456,27 @@ async function pollPartials(notificationId) {
     return null;
   }
 }
-async function awaitReply(notificationId, opts = {}) {
+async function awaitReply(notificationId, opts) {
   const intervalMs = opts.intervalMs ?? 5e3;
   const windowMs = opts.windowMs ?? AWAIT_WINDOW_MS;
   const doSleep = opts.sleep ?? sleep2;
   const now = opts.now ?? Date.now;
+  const read = opts.read;
   const start = now();
   while (true) {
     if (opts.signal?.aborted) return { type: "idle" };
-    const item = await pollAnswer(notificationId);
-    if (item.type !== "idle") return item;
-    const partial = await pollPartials(notificationId);
-    if (partial) return partial;
+    try {
+      const item = await read(notificationId);
+      if (item.type !== "idle") return item;
+      const partial = await pollPartials(notificationId);
+      if (partial) return partial;
+    } catch (e) {
+      if (!isNetworkError(e)) throw e;
+    }
     if (now() - start >= windowMs) return { type: "idle" };
     await doSleep(intervalMs);
   }
 }
-function decryptItem(item) {
-  if (item.type !== "reply") return item;
-  const enriched = { ...item, intents: landIntents(item.intents) };
-  if (!enriched.sealed) return enriched;
-  const answer = decryptAnswer(enriched);
-  const { sealed: _s, ...rest } = enriched;
-  return { ...rest, answer };
-}
-function landIntents(intents) {
-  if (!intents?.length) return intents;
-  return intents.map((i) => {
-    if (i.kind !== "defer") return i;
-    const due = parseDue(i.detail);
-    return due !== null ? { ...i, dueInSeconds: due } : i;
-  });
-}
 async function getThread(parentId) {
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/thread/${encodeURIComponent(parentId)}`, {
     headers: { authorization: `Bearer ${authToken()}` }
@@ -4196,22 +5491,16 @@ async function searchThreads(q) {
   if (!res.ok) throw new Error(`search_threads failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
-async function checkReplies(opts = {}) {
+async function sweepLeased(opts = {}) {
   const token = authToken(opts.token);
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/pending`, {
-    headers: { authorization: `Bearer ${token}` }
+    headers: {
+      authorization: `Bearer ${token}`,
+      "x-paigy-await-ack": "1"
+    }
   }));
   if (!res.ok) throw new Error(`check_replies failed: ${res.status} ${await res.text()}`);
-  const pending = await res.json();
-  return {
-    ...pending,
-    replies: pending.replies.map((raw) => {
-      const r = { ...raw, intents: landIntents(raw.intents) };
-      if (!r.sealed) return r;
-      const { sealed: _s, ...rest } = r;
-      return { ...rest, answer: decryptAnswer(r) };
-    })
-  };
+  return await res.json();
 }
 async function answerCallerQuestion(notificationId, answer) {
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/voice/session-answer`, {
@@ -4267,15 +5556,6 @@ async function heartbeat(runtime, opts = {}) {
   }));
   if (!res.ok) throw new Error(`heartbeat failed: ${res.status}`);
 }
-async function setTaskState(notificationId, state, opts = {}) {
-  const res = ensureAuthed(await reach(`${BACKEND_URL}/api/notify/${notificationId}/state`, {
-    method: "PATCH",
-    headers: { "content-type": "application/json", authorization: `Bearer ${authToken(opts.token)}` },
-    body: JSON.stringify({ state })
-  }));
-  if (!res.ok) throw new Error(`set_task_state failed: ${res.status} ${await res.text()}`);
-  return await res.json();
-}
 async function registerDelivery(mode) {
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/delivery`, {
     method: "POST",
@@ -4286,7 +5566,7 @@ async function registerDelivery(mode) {
   return await res.json();
 }
 async function scheduleCallback(req) {
-  const token = readToken();
+  const token = authToken();
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/callback`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
@@ -4296,7 +5576,7 @@ async function scheduleCallback(req) {
   return await res.json();
 }
 async function handoff(req) {
-  const token = readToken();
+  const token = authToken();
   const res = ensureAuthed(await reach(`${BACKEND_URL}/api/handoff`, {
     method: "POST",
     headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
@@ -4305,15 +5585,196 @@ async function handoff(req) {
   if (!res.ok) throw new Error(`handoff failed: ${res.status} ${await res.text()}`);
   return await res.json();
 }
+var sleep3 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var ReplyLeaseExpiredError = class extends Error {
+  constructor() {
+    super(
+      "The Paigy reply lease expired before acknowledgement. The answer remains durable; call await_reply again to reclaim it before acting."
+    );
+    this.name = "ReplyLeaseExpiredError";
+  }
+};
+var ReplyAckError = class extends Error {
+  constructor(message, retryable) {
+    super(message);
+    this.retryable = retryable;
+    this.name = "ReplyAckError";
+  }
+  retryable;
+};
+function decryptAnswer(reply, deps = {}) {
+  if (!reply.sealed) return reply.answer;
+  const keyFile = (deps.readKeyFile ?? readKeyFile)();
+  if (!keyFile?.keypair) {
+    throw new Error(
+      "received a sealed answer but this agent has no device key to open it \u2014 re-pair."
+    );
+  }
+  return openSealedAnswer(reply.sealed, keyFile.keypair);
+}
+function decodeReply(item, deps = {}) {
+  const { delivery: _delivery, ...withoutDelivery } = item;
+  const enriched = { ...withoutDelivery };
+  if (!enriched.sealed) return enriched;
+  const answer = decryptAnswer(enriched, deps);
+  const { sealed: _sealed, ...plaintext } = enriched;
+  return { ...plaintext, answer };
+}
+function deliveryOf(item) {
+  if (item.type !== "reply" || !("delivery" in item) || item.delivery === void 0) {
+    return null;
+  }
+  const delivery = item.delivery;
+  if (!delivery || typeof delivery.leaseId !== "string" || !delivery.leaseId || typeof delivery.expiresAt !== "string" || !delivery.expiresAt) {
+    throw new Error(
+      "Paigy returned invalid reply-delivery metadata; the answer was not acknowledged and remains recoverable."
+    );
+  }
+  return delivery;
+}
+async function responseDetail(res) {
+  try {
+    return (await res.text()).slice(0, 300);
+  } catch {
+    return "";
+  }
+}
+async function acknowledge(token, leaseId, opts = {}) {
+  const attempts = Math.max(1, Math.min(opts.attempts ?? 3, 5));
+  const backoffMs = Math.max(0, opts.backoffMs ?? 100);
+  const doSleep = opts.doSleep ?? sleep3;
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const res = ensureAuthed(await reach(`${BACKEND_URL}/api/await/ack`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${token}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ leaseId })
+      }));
+      if (res.ok) return;
+      const detail2 = await responseDetail(res);
+      if (res.status === 409) throw new ReplyLeaseExpiredError();
+      const retryable = res.status === 408 || res.status === 425 || res.status === 429 || res.status >= 500;
+      throw new ReplyAckError(
+        `Paigy reply acknowledgement failed: ${res.status}${detail2 ? ` ${detail2}` : ""}`,
+        retryable
+      );
+    } catch (error) {
+      if (error instanceof UnpairedError || error instanceof ReplyLeaseExpiredError || error instanceof ReplyAckError && !error.retryable) {
+        throw error;
+      }
+      lastError = error;
+      if (attempt + 1 < attempts) {
+        await doSleep(backoffMs * 2 ** attempt);
+      }
+    }
+  }
+  const detail = lastError instanceof Error ? lastError.message : String(lastError);
+  throw new Error(
+    `Could not acknowledge the Paigy reply after ${attempts} attempts (${detail}). The answer was not returned to the agent and remains recoverable after the lease expires.`
+  );
+}
+async function ackReply(item, token, opts = {}) {
+  const delivery = deliveryOf(item);
+  if (!delivery) throw new Error("Paigy returned a reply without a delivery lease; nothing to acknowledge.");
+  await acknowledge(token, delivery.leaseId, {
+    attempts: opts.ackAttempts,
+    backoffMs: opts.ackBackoffMs,
+    doSleep: opts.ackSleep
+  });
+}
+async function receiveReply(item, token, opts = {}) {
+  const decoded = decodeReply(item, opts);
+  const delivery = deliveryOf(item);
+  if (!delivery) {
+    if (opts.requireDelivery) {
+      throw new Error("Paigy returned a catch-up reply without a delivery lease; the answer was not exposed.");
+    }
+    return decoded;
+  }
+  await acknowledge(token, delivery.leaseId, {
+    attempts: opts.ackAttempts,
+    backoffMs: opts.ackBackoffMs,
+    doSleep: opts.ackSleep
+  });
+  return decoded;
+}
+async function pollAnswer(notificationId, opts = {}) {
+  const token = authToken() ?? "";
+  const res = ensureAuthed(await reach(
+    `${BACKEND_URL}/api/await?notificationId=${encodeURIComponent(notificationId)}`,
+    {
+      headers: {
+        authorization: `Bearer ${token}`,
+        "x-paigy-await-ack": "1"
+      }
+    }
+  ));
+  if (!res.ok) throw new Error(`await failed: ${res.status} ${await res.text()}`);
+  const wire = await res.json();
+  if (wire.type !== "reply") return wire;
+  return receiveReply(wire, token, opts);
+}
+async function awaitReply2(notificationId, opts = {}) {
+  return awaitReply(notificationId, { ...opts, read: pollAnswer });
+}
+async function checkReplies(opts = {}) {
+  const pending = await sweepLeased(opts);
+  const token = authToken(opts.token) ?? "";
+  const replies = await Promise.all(pending.replies.map(async (reply) => {
+    const received = await receiveReply(
+      { type: "reply", ...reply },
+      token,
+      { requireDelivery: true }
+    );
+    const { type: _type, ...withoutType } = received;
+    return withoutType;
+  }));
+  return {
+    ...pending,
+    replies,
+    work: pending.work ?? []
+  };
+}
+async function patchState(path, state, opts, operation) {
+  const token = authToken(opts.token) ?? "";
+  const res = ensureAuthed(await reach(
+    `${BACKEND_URL}${path}`,
+    {
+      method: "PATCH",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`,
+        "x-paigy-await-ack": "1"
+      },
+      body: JSON.stringify({ state })
+    }
+  ));
+  if (!res.ok) {
+    throw new Error(`${operation} failed: ${res.status} ${await res.text()}`);
+  }
+  return await res.json();
+}
+function setTaskState(notificationId, state, opts = {}) {
+  return patchState(`/api/notify/${encodeURIComponent(notificationId)}/state`, state, opts, "set_task_state");
+}
+function setWorkState(input, opts = {}) {
+  const parsed = SetWorkStateSchema.parse(input);
+  const path = parsed.workId ? `/api/work/${encodeURIComponent(parsed.workId)}/state` : `/api/notify/${encodeURIComponent(parsed.notificationId)}/state`;
+  return patchState(path, parsed.state, opts, "set_work_state");
+}
 
 export {
   BACKEND_URL,
+  isNetworkError,
   reach,
-  normalizeSpeech,
-  lintNotify,
   NotifyRequestSchema,
-  SetTaskStateSchema,
+  SetWorkStateSchema,
   ScheduleCallbackSchema,
+  contactParentId,
   AGENT_NAME,
   TOKEN_PATH,
   saveToken,
@@ -4324,7 +5785,6 @@ export {
   deleteToken,
   revokeToken,
   requestCode,
-  pollToken,
   saveKeyFile,
   readKeyFile,
   deleteKeyFile,
@@ -4333,19 +5793,25 @@ export {
   fetchCredential,
   pairStep,
   UnpairedError,
+  createGoal,
   submitNotification,
-  awaitReply,
   getThread,
   searchThreads,
-  checkReplies,
+  sweepLeased,
   answerCallerQuestion,
   overrideToken,
+  authToken,
   hatch,
   whoAmI,
   setIdentity,
   heartbeat,
-  setTaskState,
   registerDelivery,
   scheduleCallback,
-  handoff
+  handoff,
+  decodeReply,
+  ackReply,
+  awaitReply2,
+  checkReplies,
+  setTaskState,
+  setWorkState
 };