@reventlessdev/reventless-spec 3.0.0-alpha.144 → 3.0.0-alpha.145

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.145 (2026-09-24)
+
+### Features
+
+* **dcb:** a command reference no decision reads by stays out of the query ([3ae149a](https://github.com/ReventlessDev/reventless-core/commit/3ae149ae91ebab63413be57df5827c5fd4390160))
+
+
 # 3.0.0-alpha.144 (2026-09-23)
 
 * feat(node)!: every command-line tool reads its arguments through parseArgs ([2e41979](https://github.com/ReventlessDev/reventless-core/commit/2e41979b73646c46356e197e17eb4a3da0154c73))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.144",
+  "version": "3.0.0-alpha.145",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {

package/src/components/DcbScopeInference.res

@@ -10,7 +10,7 @@ a tag-metadata flag. That is precisely what we are replacing — so both the run
 VS Code tooling (building shapes from parsed `.res` source) can feed the same
 `infer`. See `docs/plans/done/dcb-tag-scope-inference.md` § "Phase 1 design".
 
-The three rules (over the representation):
+The four rules (over the representation):
 
 1. **Owner / partition.** A slice's partition key is the key its *own* emitted
    events are identified by — computed as `producedKeys(S)` minus the keys `S`
@@ -33,6 +33,12 @@ The three rules (over the representation):
    producing slice's own partition key. Foreign reference keys (e.g. `categoryId`
    on `ProductAdded`) are payload ⇒ not indexed ⇒ the sibling-leak GSI write never
    happens.
+
+4. **Command scope.** A scalar key on a *command* is a query tag iff it is the
+   slice's partition or a key the slice reads off a foreign event (rule 2's
+   candidates). `ShipOrder({orderId, carrierId})` names the carrier as information:
+   AND-ing it into the clause would hide every order event that does not carry it,
+   so it is payload. See `commandPayloadKeys`.
 */
 /** A field the slice graph treats as an entity identity.
 
@@ -55,6 +61,9 @@ type idField = {
   byTag?: bool,
   /** The tag key, when the field's type says it (an identity) rather than its name. */
   key?: string,
+  /** The author asked for the tag (`@dcbTag`, `@partitionTag`, `@crossPartition`,
+      `@compositePartitionTag`), so a command keeps it in its query (rule 4). */
+  declared?: bool,
 }
 
 /** One variant arm: its constructor name and the `*Id` fields it carries. */
@@ -397,6 +406,35 @@ let crossPartitionForSlice = (s: sliceShape): array<string> => {
   foreign->Array.filter(k => Some(k) != partition && scalar->Array.includes(k))
 }
 
+/**
+Rule 4: the scalar command keys that stay out of the slice's decision query.
+
+A key stays in when it is the partition, when the slice reads it off a foreign
+event, when the boundary reads it across partitions, when the author declared it
+on the command or on one of the slice's own arms (an M:N capacity read's
+`@crossPartition` sits on the event), or when the command also carries it as a
+list. Anything else only names another thing, and the fence is the partition.
+*/
+let commandPayloadKeys = (s: sliceShape, ~partition: string, ~crossPartition: array<string>): array<
+  string,
+> => {
+  let foreign = foreignConsumedKeys(s)
+  let declared = (f: idField) => f.declared->Option.getOr(false)
+  let pinned =
+    s.command
+    ->Array.filter(f => f.isList || declared(f))
+    ->Array.concat(
+      Array.concat(s.consumed, s.produced)->Array.flatMap(e => e.idFields->Array.filter(declared)),
+    )
+    ->Array.map(tagKeyOf)
+  commandScalarKeys(s)->Array.filter(k =>
+    k != partition &&
+    !(foreign->Array.includes(k)) &&
+    !(crossPartition->Array.includes(k)) &&
+    !(pinned->Array.includes(k))
+  )
+}
+
 let infer = (slices: array<sliceShape>): derived => {
   let {partitionBySlice, ambiguities} = resolvePartitions(slices)
 

package/src/components/DcbScopeInference.res.mjs

@@ -258,6 +258,25 @@ function crossPartitionForSlice(s) {
   });
 }
 
+function commandPayloadKeys(s, partition, crossPartition) {
+  let foreign = foreignConsumedKeys(s);
+  let declared = f => Stdlib_Option.getOr(f.declared, false);
+  let pinned = s.command.filter(f => {
+    if (f.isList) {
+      return true;
+    } else {
+      return Stdlib_Option.getOr(f.declared, false);
+    }
+  }).concat(s.consumed.concat(s.produced).flatMap(e => e.idFields.filter(declared))).map(tagKeyOf);
+  return commandScalarKeys(s).filter(k => {
+    if (k !== partition && !foreign.includes(k) && !crossPartition.includes(k)) {
+      return !pinned.includes(k);
+    } else {
+      return false;
+    }
+  });
+}
+
 function infer(slices) {
   let match = resolvePartitions(slices);
   let partitionBySlice = match.partitionBySlice;
@@ -332,6 +351,7 @@ export {
   resolvePartitions,
   partitionBlockers,
   crossPartitionForSlice,
+  commandPayloadKeys,
   infer,
 }
 /* No side effect */

package/src/components/DcbTag.res

@@ -126,6 +126,17 @@ let dcbTagKeyOverrideId: S.Metadata.Id.t<string> = S.Metadata.Id.make(
   ~name="tagKeyOverride",
 )
 
+/**
+Internal sury metadata ID marking a tag the author wrote (`@dcbTag`) rather than
+one the naming convention or the field's identity implied. A declared command tag
+always stays in the decision query; an implied one the slice does not decide by
+is payload (`DcbScopeInference.commandPayloadKeys`).
+*/
+let dcbDeclaredTagId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(
+  ~namespace="dcb",
+  ~name="declaredTag",
+)
+
 /**
 Type-preserving forms of the markers below, for a field whose schema is not a
 bare `S.string` — an identity (`OrderId.schema->DcbTag.mark`) keeps its type and
@@ -143,6 +154,12 @@ let markPartition = (schema: S.t<'a>): S.t<'a> =>
 let markCrossPartition = (schema: S.t<'a>): S.t<'a> =>
   schema->mark->S.Metadata.set(~id=dcbCrossPartitionId, true)
 
+let markDeclared = (schema: S.t<'a>): S.t<'a> =>
+  schema->mark->S.Metadata.set(~id=dcbDeclaredTagId, true)
+
+let markDeclaredForKey = (schema: S.t<'a>, ~key: string): S.t<'a> =>
+  schema->markForKey(~key)->S.Metadata.set(~id=dcbDeclaredTagId, true)
+
 /**
 A sury string schema annotated as a DCB tag field.
 
@@ -190,6 +207,11 @@ annotations carrying a string payload.
 */
 let stringForKey = (~key: string): S.t<string> => S.string->markForKey(~key)
 
+/** What `@dcbTag` emits: `string` / `stringForKey`, marked as written by the author. */
+let declared: S.t<string> = S.string->markDeclared
+
+let declaredForKey = (~key: string): S.t<string> => S.string->markDeclaredForKey(~key)
+
 /**
 A sury int schema annotated as a DCB tag field.
 Use with `@s.matches(DcbTag.int)` on integer fields that should be extracted as tags.
@@ -359,6 +381,14 @@ let isPartitionTag = (fieldSchema: S.t<unknown>) =>
 let isCrossPartitionTag = (fieldSchema: S.t<unknown>) =>
   S.Metadata.get(fieldSchema, ~id=dcbCrossPartitionId)->Option.isSome
 
+/** Returns `true` if the author asked for the tag: `@dcbTag`, `@partitionTag`,
+    `@crossPartition` or `@compositePartitionTag`. */
+let isDeclaredTag = (fieldSchema: S.t<unknown>) =>
+  S.Metadata.get(fieldSchema, ~id=dcbDeclaredTagId)->Option.isSome ||
+  isPartitionTag(fieldSchema) ||
+  isCrossPartitionTag(fieldSchema) ||
+  S.Metadata.get(fieldSchema, ~id=dcbCompositePartitionMemberId)->Option.isSome
+
 /**
 Returns `true` if the schema is an array whose item schema is a cross-partition
 DCB tag (`array<@s.matches(DcbTag.crossPartition) string>`).
@@ -926,6 +956,10 @@ pairing matches nothing, so results are unchanged. A type that carries the tag
 as a *secondary* tag is retained (a legitimate cross-partition read), and a type
 absent from the map is kept (cannot be proven vacuous).
 
+`~payloadTagKeys` (`commandPayloadTagKeys`) are command keys the slice does not
+decide by; they are left out of every clause, so they narrow neither the read nor
+the append condition.
+
 @example
 ```rescript
 // Single-entity command → single AND clause
@@ -953,20 +987,23 @@ let buildQueryFromCommand = (
   ~value: 'a,
   ~tagKeysByEventType: dict<array<string>>=Dict.make(),
   ~crossPartitionTagKeys: array<string>=[],
+  ~payloadTagKeys: array<string>=[],
 ): query => {
   let typesForTags = clauseTags =>
     narrowEventTypesForTags(eventTypes, clauseTags, tagKeysByEventType)
+  let decidedBy = (tags: array<tag>) =>
+    tags->Array.filter(tag => !(payloadTagKeys->Array.includes(tag.key)))
   if hasTaggedArrayFields(schema) {
     // Array fields already fan out per element into single-tag clauses, so a
     // cross-partition array tag is already its own clause (the adapter routes it
     // by `crossPartitionTagKeys`).
-    let tags = extractTagsExpanded(schema, value)
+    let tags = extractTagsExpanded(schema, value)->decidedBy
     tags->Array.map(tag => {
       let clauseTags = [{key: tag.key, value: tag.value}]
       {eventTypes: typesForTags(clauseTags), tags: clauseTags}
     })
   } else {
-    let tags = extractTags(schema, value)
+    let tags = extractTags(schema, value)->decidedBy
     // When any command tag is cross-partition, fan every scalar tag out into its
     // own single-tag clause instead of AND-ing them into one composite
     // (exact-pair) clause. An M:N command (`SubscribeStudent({courseId, studentId})`)
@@ -1108,11 +1145,18 @@ let idFieldsOfProperties = (properties: dict<S.t<unknown>>): array<DcbScopeInfer
     } else {
       None
     }
+  let isDeclared = (fieldSchema: S.t<unknown>, isList) => {
+    let valueSchema = switch (isList, fieldSchema) {
+    | (true, Array({additionalItems: Schema(item)})) => item
+    | _ => fieldSchema
+    }
+    valueSchema->Semantic.unwrapOptional->Option.getOr(valueSchema)->isDeclaredTag
+  }
   let identity = (name, fieldSchema, isList) =>
     switch typedKey(fieldSchema, isList) {
     | Some(key) => Some({DcbScopeInference.name, isList, key})
     | None => untypedIdentity(name, fieldSchema, isList)
-    }
+    }->Option.map(f => isDeclared(fieldSchema, isList) ? {...f, declared: true} : f)
   properties
   ->Dict.toArray
   ->Array.flatMap(((name, fieldSchema)) => {
@@ -1337,6 +1381,27 @@ let deriveEffectiveScope = (slices: array<sliceSchemas>): effectiveScope => {
   }
 }
 
+/**
+The command tag keys a slice's decision query leaves out (rule 4 of
+`DcbScopeInference`), given the slice's partition within its boundary and the
+boundary's cross-partition keys. Empty unless the partition is a single key: a
+composite boundary keeps every tag it has.
+*/
+let commandPayloadTagKeys = (
+  shape: DcbScopeInference.sliceShape,
+  ~partitionTag: option<derivedPartitionTag>,
+  ~crossPartitionTagKeys: array<string>,
+): array<string> =>
+  switch partitionTag {
+  | Some(Simple({key})) =>
+    DcbScopeInference.commandPayloadKeys(
+      shape,
+      ~partition=key,
+      ~crossPartition=crossPartitionTagKeys,
+    )
+  | _ => []
+  }
+
 // --- Composite partition key helpers ---
 
 type compositePartitionFieldInfo = {name: string, position: int, sep: string}

package/src/components/DcbTag.res.mjs

@@ -32,6 +32,8 @@ let dcbCompositePartitionMemberId = Sury.$Metadata_Id_make("dcb", "compositePart
 
 let dcbTagKeyOverrideId = Sury.$Metadata_Id_make("dcb", "tagKeyOverride");
 
+let dcbDeclaredTagId = Sury.$Metadata_Id_make("dcb", "declaredTag");
+
 function mark(schema) {
   return Sury.$Metadata_set(schema, dcbTagId, true);
 }
@@ -48,12 +50,26 @@ function markCrossPartition(schema) {
   return Sury.$Metadata_set(Sury.$Metadata_set(schema, dcbTagId, true), dcbCrossPartitionId, true);
 }
 
+function markDeclared(schema) {
+  return Sury.$Metadata_set(Sury.$Metadata_set(schema, dcbTagId, true), dcbDeclaredTagId, true);
+}
+
+function markDeclaredForKey(schema, key) {
+  return Sury.$Metadata_set(markForKey(schema, key), dcbDeclaredTagId, true);
+}
+
 let string = Sury.$Metadata_set(Sury.string, dcbTagId, true);
 
 function stringForKey(key) {
   return markForKey(Sury.string, key);
 }
 
+let declared = markDeclared(Sury.string);
+
+function declaredForKey(key) {
+  return markDeclaredForKey(Sury.string, key);
+}
+
 let int = Sury.$Metadata_set(Sury.int32, dcbTagId, true);
 
 let partition = markPartition(Sury.string);
@@ -172,6 +188,14 @@ function isCrossPartitionTag(fieldSchema) {
   return Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbCrossPartitionId));
 }
 
+function isDeclaredTag(fieldSchema) {
+  if (Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbDeclaredTagId)) || Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbPartitionTagId)) || Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbCrossPartitionId))) {
+    return true;
+  } else {
+    return Stdlib_Option.isSome(Sury.$Metadata_get(fieldSchema, dcbCompositePartitionMemberId));
+  }
+}
+
 function isCrossPartitionTaggedArray(fieldSchema) {
   if (fieldSchema.type !== "array") {
     return false;
@@ -610,11 +634,13 @@ function narrowEventTypesForTags(eventTypes, tags, tagKeysByEventType) {
   });
 }
 
-function buildQueryFromCommand(eventTypes, schema, value, tagKeysByEventTypeOpt, crossPartitionTagKeysOpt) {
+function buildQueryFromCommand(eventTypes, schema, value, tagKeysByEventTypeOpt, crossPartitionTagKeysOpt, payloadTagKeysOpt) {
   let tagKeysByEventType = tagKeysByEventTypeOpt !== undefined ? tagKeysByEventTypeOpt : ({});
   let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let payloadTagKeys = payloadTagKeysOpt !== undefined ? payloadTagKeysOpt : [];
+  let decidedBy = tags => tags.filter(tag => !payloadTagKeys.includes(tag.key));
   if (hasTaggedArrayFields(schema)) {
-    let tags = extractTagsExpanded(schema, value);
+    let tags = decidedBy(extractTagsExpanded(schema, value));
     return tags.map(tag => {
       let clauseTags = [{
           key: tag.key,
@@ -626,7 +652,7 @@ function buildQueryFromCommand(eventTypes, schema, value, tagKeysByEventTypeOpt,
       };
     });
   }
-  let tags$1 = extractTags(schema, value);
+  let tags$1 = decidedBy(extractTags(schema, value));
   let hasCrossPartition = tags$1.some(tag => crossPartitionTagKeys.includes(tag.key));
   if (hasCrossPartition && tags$1.length > 1) {
     return tags$1.map(tag => {
@@ -735,15 +761,8 @@ function idFieldsOfProperties(properties) {
     }
     return Stdlib_Option.map(Semantic$Reventless.identityKey(valueSchema), param => resolveTagKey("", valueSchema));
   };
-  let identity = (name, fieldSchema, isList) => {
-    let key = typedKey(fieldSchema, isList);
-    if (key !== undefined) {
-      return {
-        name: name,
-        isList: isList,
-        key: key
-      };
-    } else if (isIdName(name)) {
+  let untypedIdentity = (name, fieldSchema, isList) => {
+    if (isIdName(name)) {
       return {
         name: name,
         isList: isList
@@ -758,6 +777,31 @@ function idFieldsOfProperties(properties) {
       return;
     }
   };
+  let isDeclared = (fieldSchema, isList) => {
+    let valueSchema;
+    if (isList && fieldSchema.type === "array") {
+      let item = fieldSchema.additionalItems;
+      valueSchema = item === "strip" || item === "strict" ? fieldSchema : item;
+    } else {
+      valueSchema = fieldSchema;
+    }
+    return isDeclaredTag(Stdlib_Option.getOr(Semantic$Reventless.unwrapOptional(valueSchema), valueSchema));
+  };
+  let identity = (name, fieldSchema, isList) => {
+    let key = typedKey(fieldSchema, isList);
+    return Stdlib_Option.map(key !== undefined ? ({
+        name: name,
+        isList: isList,
+        key: key
+      }) : untypedIdentity(name, fieldSchema, isList), f => {
+      if (!isDeclared(fieldSchema, isList)) {
+        return f;
+      }
+      let newrecord = {...f};
+      newrecord.declared = true;
+      return newrecord;
+    });
+  };
   return Object.entries(properties).flatMap(param => {
     let fieldSchema = param[1];
     let isList;
@@ -895,6 +939,19 @@ function deriveEffectiveScope(slices) {
   };
 }
 
+function commandPayloadTagKeys(shape, partitionTag, crossPartitionTagKeys) {
+  if (partitionTag === undefined) {
+    return [];
+  }
+  switch (partitionTag.TAG) {
+    case "Simple" :
+      return DcbScopeInference$Reventless.commandPayloadKeys(shape, partitionTag._0.key, crossPartitionTagKeys);
+    case "Composite" :
+    case "ByEventType" :
+      return [];
+  }
+}
+
 function extractCompositePartitionFieldsFromProperties(properties) {
   return Stdlib_Array.filterMap(Object.entries(properties), param => {
     let meta = Sury.$Metadata_get(param[1], dcbCompositePartitionMemberId);
@@ -1084,12 +1141,17 @@ export {
   dcbCrossPartitionId,
   dcbCompositePartitionMemberId,
   dcbTagKeyOverrideId,
+  dcbDeclaredTagId,
   mark,
   markForKey,
   markPartition,
   markCrossPartition,
+  markDeclared,
+  markDeclaredForKey,
   string,
   stringForKey,
+  declared,
+  declaredForKey,
   int,
   partition,
   crossPartition,
@@ -1105,6 +1167,7 @@ export {
   hasNestedTags,
   isPartitionTag,
   isCrossPartitionTag,
+  isDeclaredTag,
   isCrossPartitionTaggedArray,
   resolveTagKey,
   resolveArrayTagKey,
@@ -1140,6 +1203,7 @@ export {
   sliceShapeFromSchemas,
   sliceShape,
   deriveEffectiveScope,
+  commandPayloadTagKeys,
   extractCompositePartitionFieldsFromProperties,
   extractCompositePartitionFields,
   getCompositePartitionKeyValue,

package/src/components/DcbValidation.res

@@ -170,20 +170,24 @@ exact-match trap. Returns one `validationError` (warning) per offending
 
 @param slices `(sliceName, commandSchema, consumedEventSchema)` per consumer.
 @param producedTagKeys event type → its produced tag-key set (from the event-log schema).
+@param payloadTagKeysBySlice slice → the command keys its query leaves out
+(`DcbTag.commandPayloadTagKeys`), which take no part in a composite read.
 */
 let validateCompositeReads = (
   ~slices: array<(string, S.t<unknown>, S.t<unknown>)>,
   ~producedTagKeys: dict<array<string>>,
+  ~payloadTagKeysBySlice: dict<array<string>>=Dict.make(),
 ): array<validationError> => {
   let warnings: array<validationError> = []
   slices->Array.forEach(((sliceName, commandSchema, consumedSchema)) =>
     if !DcbTag.hasTaggedArrayFields(commandSchema) {
       let commandTagKeysByVariant = DcbTag.extractTagKeysByEventType(commandSchema)
       let consumedTypes = DcbTag.extractVariantNames(consumedSchema)
+      let payload = payloadTagKeysBySlice->Dict.get(sliceName)->Option.getOr([])
       commandTagKeysByVariant
       ->Dict.valuesToArray
       ->Array.forEach(cmdKeys => {
-        let querySet = dedupeKeys(cmdKeys)
+        let querySet = dedupeKeys(cmdKeys)->Array.filter(k => !(payload->Array.includes(k)))
         if querySet->Array.length >= 2 {
           consumedTypes->Array.forEach(
             consumedType =>
@@ -564,3 +568,40 @@ let validatePartitionHintsVsInference = (
   )
   {contradictions, redundancies}
 }
+
+/**
+Finds `@noDcbTag` on command fields whose key the slice's query leaves out anyway
+(rule 4 of `DcbScopeInference`). Such a reference is payload without the
+annotation, so the annotation can go.
+
+The PPX consumes the attribute, so the caller reads the suppressed fields off the
+source. A field the shape does not know (a name that is no identity) is skipped.
+
+@param suppressedBySlice slice → the command fields written `@noDcbTag`.
+@param payloadTagKeysBySlice slice → `DcbTag.commandPayloadTagKeys`.
+*/
+let validateCommandTagSuppressions = (
+  ~shapes: array<DcbScopeInference.sliceShape>,
+  ~suppressedBySlice: dict<array<string>>,
+  ~payloadTagKeysBySlice: dict<array<string>>,
+): array<validationError> =>
+  shapes->Array.flatMap(s => {
+    let payload = payloadTagKeysBySlice->Dict.get(s.sliceName)->Option.getOr([])
+    suppressedBySlice
+    ->Dict.get(s.sliceName)
+    ->Option.getOr([])
+    ->Array.filterMap(field =>
+      s.command
+      ->Array.find(f => f.name == field)
+      ->Option.map(DcbScopeInference.tagKeyOf)
+      ->Option.flatMap(
+        key =>
+          payload->Array.includes(key)
+            ? Some({
+                sliceName: s.sliceName,
+                message: `@noDcbTag ${field} is what inference derives without it — ${s.sliceName} decides nothing by ${key}, so it stays out of the query anyway. The annotation is redundant and can be removed.`,
+              })
+            : None,
+      )
+    )
+  })

package/src/components/DcbValidation.res.mjs

@@ -191,7 +191,8 @@ function dedupeKeys(keys) {
   });
 }
 
-function validateCompositeReads(slices, producedTagKeys) {
+function validateCompositeReads(slices, producedTagKeys, payloadTagKeysBySliceOpt) {
+  let payloadTagKeysBySlice = payloadTagKeysBySliceOpt !== undefined ? payloadTagKeysBySliceOpt : ({});
   let warnings = [];
   slices.forEach(param => {
     let commandSchema = param[1];
@@ -201,8 +202,9 @@ function validateCompositeReads(slices, producedTagKeys) {
     }
     let commandTagKeysByVariant = DcbTag$Reventless.extractTagKeysByEventType(commandSchema);
     let consumedTypes = DcbTag$Reventless.extractVariantNames(param[2]);
+    let payload = Stdlib_Option.getOr(payloadTagKeysBySlice[sliceName], []);
     Object.values(commandTagKeysByVariant).forEach(cmdKeys => {
-      let querySet = dedupeKeys(cmdKeys);
+      let querySet = dedupeKeys(cmdKeys).filter(k => !payload.includes(k));
       if (querySet.length >= 2) {
         consumedTypes.forEach(consumedType => {
           let producedKeys = producedTagKeys[consumedType];
@@ -491,6 +493,20 @@ function validatePartitionHintsVsInference(shapes) {
   };
 }
 
+function validateCommandTagSuppressions(shapes, suppressedBySlice, payloadTagKeysBySlice) {
+  return shapes.flatMap(s => {
+    let payload = Stdlib_Option.getOr(payloadTagKeysBySlice[s.sliceName], []);
+    return Stdlib_Array.filterMap(Stdlib_Option.getOr(suppressedBySlice[s.sliceName], []), field => Stdlib_Option.flatMap(Stdlib_Option.map(s.command.find(f => f.name === field), DcbScopeInference$Reventless.tagKeyOf), key => {
+      if (payload.includes(key)) {
+        return {
+          sliceName: s.sliceName,
+          message: `@noDcbTag ` + field + ` is what inference derives without it — ` + s.sliceName + ` decides nothing by ` + key + `, so it stays out of the query anyway. The annotation is redundant and can be removed.`
+        };
+      }
+    }));
+  });
+}
+
 export {
   extractVariantInfo,
   extractAllVariants,
@@ -505,5 +521,6 @@ export {
   validateCrossPartitionScope,
   validateScopeVsInference,
   validatePartitionHintsVsInference,
+  validateCommandTagSuppressions,
 }
 /* DcbTag-Reventless Not a pure module */