node-autotask 0.39.0 → 0.39.1

package/dist/{chunk-RAZEXOLC.cjs → chunk-VR6RYXTD.cjs}

@@ -2,7 +2,7 @@
 var CAPABILITY_GROUPS = {
   "B": {
     "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
-    "builtAt": "2026-10-29T10:49:12.431Z",
+    "builtAt": "2026-10-29T20:28:49.329Z",
     "records": [
       {
         "id": "appointments.count",
@@ -617,7 +617,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -1469,7 +1469,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -2108,7 +2108,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -3766,7 +3766,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -4983,7 +4983,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -5821,7 +5821,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -6883,7 +6883,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -7655,7 +7655,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -8527,7 +8527,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -9568,7 +9568,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -10496,7 +10496,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -11528,7 +11528,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -12359,7 +12359,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -13396,7 +13396,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -14221,7 +14221,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -15059,7 +15059,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -15941,7 +15941,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -16823,7 +16823,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -17695,7 +17695,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -18660,7 +18660,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -19875,7 +19875,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -20899,7 +20899,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -21954,7 +21954,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -23172,7 +23172,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -24223,7 +24223,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -25160,7 +25160,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -26194,7 +26194,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -26844,7 +26844,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -27520,7 +27520,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -28467,7 +28467,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -29218,7 +29218,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -29977,7 +29977,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -30722,7 +30722,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -31717,7 +31717,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -32691,7 +32691,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -33539,7 +33539,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -34298,7 +34298,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -35171,7 +35171,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -35950,7 +35950,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -36808,7 +36808,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -37556,7 +37556,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -38222,7 +38222,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -39464,7 +39464,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -40780,7 +40780,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -42009,7 +42009,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -43011,7 +43011,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -43888,7 +43888,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -44713,7 +44713,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -45538,7 +45538,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -46363,7 +46363,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -47194,7 +47194,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -47959,7 +47959,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -48857,7 +48857,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -49832,7 +49832,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -50595,7 +50595,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -51241,7 +51241,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -51912,7 +51912,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -52878,7 +52878,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -53715,7 +53715,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -54650,7 +54650,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -55503,7 +55503,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -56242,7 +56242,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -57134,7 +57134,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -57810,7 +57810,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -58751,7 +58751,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -59603,7 +59603,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -64010,7 +64010,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -65696,7 +65696,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -66459,7 +66459,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -67003,7 +67003,7 @@ var CAPABILITY_GROUPS = {
   },
   "A": {
     "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
-    "builtAt": "2026-10-29T10:49:12.432Z",
+    "builtAt": "2026-10-29T20:28:49.330Z",
     "records": [
       {
         "id": "companies.count",
@@ -68160,7 +68160,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -70026,7 +70026,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -70985,7 +70985,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -71968,7 +71968,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -72957,7 +72957,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -73969,7 +73969,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -75009,7 +75009,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -75870,7 +75870,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -76643,7 +76643,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -77577,7 +77577,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -78335,7 +78335,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -79400,7 +79400,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -81114,7 +81114,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -82260,7 +82260,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -83858,7 +83858,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -85192,7 +85192,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -86039,7 +86039,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -86877,7 +86877,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -87934,7 +87934,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -88981,7 +88981,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -89806,7 +89806,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -90571,7 +90571,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -91445,7 +91445,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -92295,7 +92295,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -93133,7 +93133,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -93971,7 +93971,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -95531,7 +95531,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -96296,7 +96296,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -97056,7 +97056,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -97920,7 +97920,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -98770,7 +98770,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -100246,7 +100246,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -102518,7 +102518,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -103875,7 +103875,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -104998,7 +104998,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -105769,7 +105769,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -106846,7 +106846,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -107833,7 +107833,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -108965,7 +108965,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -110118,7 +110118,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -111067,7 +111067,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -111927,7 +111927,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -113134,7 +113134,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -114126,7 +114126,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -115017,7 +115017,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -116235,7 +116235,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -117155,7 +117155,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -118087,7 +118087,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -118939,7 +118939,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -120005,7 +120005,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -121083,7 +121083,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -122467,7 +122467,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -123401,7 +123401,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -124247,7 +124247,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -126642,7 +126642,7 @@ var CAPABILITY_GROUPS = {
           "params": {
             "type": "object",
             "required": false,
-            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; a names summary appears only when the 20 uncached name-read cap left ids unlabelled; false = raw ids), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
+            "description": `The query params object (CLOSED \u2014 unknown keys are refused pre-request with a typed error naming the key + the valid keys): { filter?: FilterCondition[], limit?: number (total cap, default 500, max 2500 \u2014 NOT a page size), latest?: number (1-2500; the N highest-id rows \u2014 the vendor has no sort; count-probe + id-threshold semantics, see docs/API.md \xA74; the same-process latest-walk count probes are briefly cached per client \u2014 a 30 s TTL, cleared on a write through this client (a probe in flight across the write is discarded by the cache's invalidation epoch \u2014 issue #139); the plain count op and aggregate stay fresh \u2014 issue #127; limit and latest may coexist only when limit >= latest), noteChars?: number (integer >= 1; opt-in per-field char cap on the untrusted-class free-text fields of the resource (notes/descriptions/UDF prose): each capped value = the first N chars + the explicit marker \u2026 [+N chars truncated] (N = chars removed), applied at result-build BEFORE the server-side untrusted wrapper; absent = the raw, untruncated result), fieldsPreset?: string (a closed includeFields preset name \u2014 v1: "billing_join" (billing_items): resolved to its field list pre-walk, the vendor column selection on the IncludeFields wire; mutually exclusive with an explicit includeFields; docs/API.md \xA711.23), includeFields?: string[], fieldCheck?: boolean (default true: every includeFields NAME and every filter condition FIELD NAME is checked pre-request against the live field set (the vendored spec when that read faults \u2014 the resource's plan-pinned live-only fields, metadata.liveOnlyFields, are exempt from the vendored refusal: the live entity carries them and the vendor model omits them (e.g. time_entries postedDate/postedOnTime) \u2014 a truly unknown name is still refused); a refusal costs zero QUERY wire \u2014 the query POST and the count probe that anchors latest are never issued, a COLD fieldCache performs one authority metadata GET first (zero on a warm one); the one udf:true condition per query is exempt (a tenant UDF name is absent from the vendored spec by definition); false disables both name checks, never the shape/grammar checks; the count verb's bag is name-checked the same way (issue #140) and carries the same fieldCheck opt-out (issue #145); a direct queryBounded/queryAll call is not checked (no bag contract there)), names?: boolean (default true \u2014 rows gain label siblings: picklist <field>Label (statusLabel), <fk>Name for companyID/contractID/ticketID/roleID/billingCodeID/*ResourceID (contractIDName, assignedResourceIDName) \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); a names summary appears only when something was left unlabelled (the 20 uncached name-read cap, an unresolved picklist value, or a failed field-catalog read: names.catalogError); false = raw ids, ~30% smaller on a full tickets row), via?: "post" | "get" (vendor GET has a 2048-char cap) }. Filter grammar: 13 operators (eq, noteq, gt, gte, lt, lte, beginsWith, endsWith, contains, exist, notExist, in, notIn; in/notIn: array or "1,2,3") + and/or grouping (no not-group); field names in vendor API casing (via operations.fieldCatalog); caps: 500 OR-conditions / 1 UDF / 8000 chars.`,
             "properties": [
               {
                 "name": "filter",
@@ -127743,7 +127743,7 @@ var CAPABILITY_GROUPS = {
   },
   "operations": {
     "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
-    "builtAt": "2026-10-29T10:49:12.432Z",
+    "builtAt": "2026-10-29T20:28:49.330Z",
     "records": [
       {
         "id": "operations.aggregate",
@@ -127770,7 +127770,7 @@ var CAPABILITY_GROUPS = {
           "opts": {
             "type": "object",
             "required": false,
-            "description": "AggregateOptions \u2014 { groupBy?: string[] (vendor field names), sum?: string[] (numeric vendor fields), top?: number (default 25, clamped 1..100 \u2014 the group-row cap), limit?: number (total-record cap for the walk modes, default 2500 = the house BOUNDED_QUERY_MAX_LIMIT \u2014 the hard max), names?: boolean (default true \u2014 group keys gain label siblings, e.g. key.ticketIDName, key.statusLabel \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; false = raw ids) }. NEITHER groupBy nor sum = COUNT mode (one vendor /query/count call \u2014 no walk; a 0 on a plan-pinned blind surface is marked blind: true with the S12-C sentinel \u2014 never a silent absence; a FILTERED 0 on an unfiltered-blind surface is a true zero). The walk modes fold client-side: hasMore/totalScanned carry the truncation honesty (no silent partial sums) and a mid-walk RATE_LIMITED propagates (the partial fold is discarded).",
+            "description": "AggregateOptions \u2014 { groupBy?: string[] (vendor field names), sum?: string[] (numeric vendor fields), top?: number (default 25, clamped 1..100 \u2014 the group-row cap), limit?: number (total-record cap for the walk modes, default 2500 = the house BOUNDED_QUERY_MAX_LIMIT \u2014 the hard max), names?: boolean (default true \u2014 group keys gain label siblings, e.g. key.ticketIDName, key.statusLabel \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); false = raw ids) }. NEITHER groupBy nor sum = COUNT mode (one vendor /query/count call \u2014 no walk; a 0 on a plan-pinned blind surface is marked blind: true with the S12-C sentinel \u2014 never a silent absence; a FILTERED 0 on an unfiltered-blind surface is a true zero). The walk modes fold client-side: hasMore/totalScanned carry the truncation honesty (no silent partial sums) and a mid-walk RATE_LIMITED propagates (the partial fold is discarded).",
             "properties": [
               {
                 "name": "groupBy",
@@ -128016,7 +128016,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -128135,7 +128135,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -128258,7 +128258,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -128391,7 +128391,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -128520,7 +128520,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -128543,7 +128543,7 @@ var CAPABILITY_GROUPS = {
           "opts": {
             "type": "object",
             "required": false,
-            "description": "FetchManyOptions \u2014 { maxItems?: number (may lower the 20-item cap, never raise it), names?: boolean (default true \u2014 found records gain label siblings, e.g. statusLabel, contractIDName \u2014 null, never missing, when the field is keyed with a null/0 or unresolved value; false = raw records), liveFields?: boolean (opt-in live field validation \u2014 requested fields are validated against the tenant's LIVE entity field metadata (the cached metadata channel: a warm fieldCache costs zero wire; a cold run is one entityInformation/fields GET per distinct resource in the batch); when a resource's metadata is unavailable the validation falls back to the vendored-spec field set for that resource; when available the live set is authoritative \u2014 a field it lacks is refused even if the spec lists it, and a live field the spec lacks (e.g. time_entries postedDate) is accepted) }",
+            "description": "FetchManyOptions \u2014 { maxItems?: number (may lower the 20-item cap, never raise it), names?: boolean (default true \u2014 found records gain label siblings, e.g. statusLabel, contractIDName \u2014 null, never missing, when the field is keyed with a null value, a 0 id or an unresolved value (a picklist 0 is labelled when the picklist defines it); false = raw records), liveFields?: boolean (opt-in live field validation \u2014 requested fields are validated against the tenant's LIVE entity field metadata (the cached metadata channel: a warm fieldCache costs zero wire; a cold run is one entityInformation/fields GET per distinct resource in the batch); when a resource's metadata is unavailable the validation falls back to the vendored-spec field set for that resource; when available the live set is authoritative \u2014 a field it lacks is refused even if the spec lists it, and a live field the spec lacks (e.g. time_entries postedDate) is accepted) }",
             "properties": [
               {
                 "name": "maxItems",
@@ -128712,7 +128712,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -128952,7 +128952,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -129087,7 +129087,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -129255,7 +129255,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -129362,7 +129362,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -129466,7 +129466,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -129834,7 +129834,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -129948,7 +129948,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       },
       {
@@ -130065,7 +130065,7 @@ var CAPABILITY_GROUPS = {
         "staleCheck": {
           "planHash": "9bb87de7bcbda60f6c44955dba52b8e61e9c5547750ea8acacfcb6f261d7734f",
           "sourceFile": "src/operations/index.ts",
-          "sourceHash": "b4d6ab1e99e967439ce3d56028984701796de5ea2c5c941bda4897f6b14d1c19"
+          "sourceHash": "66b9818ed94330f4ef2bef2698b1902b81cf1b0f3dc325e2a53b3204e4a6463e"
         }
       }
     ]