@reventlessdev/trait-notification 1.0.0-alpha.3 → 1.0.0-alpha.4

package/src/Notification_Scaffold.res

@@ -12,9 +12,8 @@ written whole; the two **relays** are printed, because what a host's events mean
 is the one thing a trait cannot be told in names.
 
 **What it does not do.** It never writes the host's wording. What a confirmation
-says is the host's sentence, and a config field for it would be a template
-language nobody asked for. It is left as a `TODO(graft)` marker in a string
-literal, which compiles, runs, and is obvious in a diff.
+says is the host's sentence, so the emitted rule table carries a `TODO(graft)`
+marker in place of one — it compiles, runs, and is obvious in a diff.
 */
 
 /**
@@ -77,6 +76,7 @@ type output = {files: array<file>, patches: array<patch>}
 
 type names = {
   slice: string,
+  claims: string,
   send: string,
   relay: string,
   intake: string,
@@ -94,6 +94,12 @@ type names = {
   requested: string,
   suppressed: string,
   undeliverable: string,
+  deferred: string,
+  claimed: string,
+  released: string,
+  claimCmd: string,
+  releaseCmd: string,
+  claimError: string,
   delivered: string,
   failed: string,
   unknownError: string,
@@ -104,6 +110,7 @@ let namesOf = (c: config): names => {
   let n = c.noun
   {
     slice: n ++ "Preferences",
+    claims: "NotificationSourceClaims",
     send: "Send" ++ n ++ "Notification",
     relay: "Announce" ++ n ++ "Contact",
     intake: n ++ "NotificationIntake",
@@ -121,6 +128,12 @@ let namesOf = (c: config): names => {
     requested: "NotificationRequested",
     suppressed: "NotificationSuppressed",
     undeliverable: "NotificationUndeliverable",
+    deferred: "NotificationDeferred",
+    claimed: "NotificationSourceClaimed",
+    released: "NotificationSourceReleased",
+    claimCmd: "ClaimNotificationSource",
+    releaseCmd: "ReleaseNotificationSource",
+    claimError: "ClaimRefused",
     delivered: "NotificationDelivered",
     failed: "NotificationFailed",
     unknownError: n ++ "Unknown",
@@ -134,6 +147,24 @@ let lines = (ls: array<string>) => ls->Array.join("\n")
 let addressA = (c: config) => c.addressA->Option.getOr("buyer@example.com")
 let addressB = (c: config) => c.addressB->Option.getOr("new@example.com")
 
+/** What the occurrence is about, named from the id it is keyed by: `"orderId"` ⇒
+    `"Order"`. Derived rather than configured because `*Id` naming already says
+    which entity an id belongs to everywhere else, and a config field would be one
+    more thing to get out of step with `occurrenceId`. Emitted as a literal in the
+    graft, so a host whose component is registered under another name edits one
+    line rather than discovering the convention. */
+let subjectTypeOf = (c: config) => {
+  let stem = c.occurrenceId->String.endsWith("Id")
+    ? c.occurrenceId->String.slice(~start=0, ~end=c.occurrenceId->String.length - 2)
+    : c.occurrenceId
+  switch stem {
+  | "" => "Subject"
+  | s =>
+    (s->String.slice(~start=0, ~end=1))->String.toUpperCase ++
+      s->String.slice(~start=1, ~end=s->String.length)
+  }
+}
+
 // `@authorize` is the host's policy, so an absent one emits nothing at all
 // rather than a permissive default.
 let authorizeOn = (c: config) =>
@@ -183,13 +214,24 @@ let sliceSpec = (c: config): string => {
           `  | Sms`,
           `  | Push`,
           ``,
-          `// Its own past facts, and nothing else — which is what lets one component hold`,
-          `// the directory and make the dispatch decision.`,
+          `// Why a request exists: the compiled table in the relay, or a rule somebody`,
+          `// configured on top of it. Recorded on the request that goes out, so "which`,
+          `// wording was in force when this was sent" has an answer.`,
+          `@schema`,
+          `type origin =`,
+          `  | Default`,
+          `  | Configured({ruleId: string, ruleVersion: string})`,
+          ``,
+          `// Its own past facts, plus the claim set from ${n.claims}. Claims are per`,
+          `// source and this slice is per recipient, so they come from another partition —`,
+          `// see \`${n.requestCmd}\` for what makes that read happen.`,
           `@schema`,
           `type consumedEvent =`,
           `  | ${n.announced}({${id}: string, ${c.contactField}: string})`,
           `  | ${n.subscribed}({${id}: string, category: category, channel: channel})`,
           `  | ${n.unsubscribed}({${id}: string, category: category, channel: channel})`,
+          `  | ${n.claimed}({sourceId: string, by: string})`,
+          `  | ${n.released}({sourceId: string})`,
           ``,
           `@schema`,
           `type command =`,
@@ -202,13 +244,32 @@ let sliceSpec = (c: config): string => {
           `${auth}${n.unsubscribeCmd}({@owner ${id}: string, category: category, channel: channel})`,
           `  // Also relayed. \`reference\` is the requester's own key, echoed back on`,
           `  // whichever outcome follows, so the relay can tell its work is finished.`,
+          `  // \`subjectType\`/\`subjectRef\` say what the notification is ABOUT, which the`,
+          `  // reference deliberately does not: its format is the requester's own`,
+          `  // business, so a row keyed by it alone cannot be read back. Empty is legal.`,
+          `  // Named \`*Ref\` and not \`*Id\` on purpose: two inferences read id fields by`,
+          `  // NAME — the DCB partition and the queryable's key field — and a second`,
+          `  // \`*Id\` on the row makes both ambiguous, which costs the view its filter`,
+          `  // and its orderBy with no error anywhere.`,
           `  | @noApi`,
           `  ${n.requestCmd}({`,
           `      ${id}: string,`,
           `      category: category,`,
           `      reference: string,`,
+          `      subjectType: string,`,
+          `      subjectRef: string,`,
           `      subject: string,`,
           `      body: string,`,
+          `      // Which stream this came from, \`"<log>:<eventType>"\`, and who is asking.`,
+          `      // A \`Default\` request for a source another producer has claimed yields;`,
+          `      // a \`Configured\` one always goes through.`,
+          `      //`,
+          `      // \`sourceId\` is a DCB tag and has to be: the decision reads claim facts`,
+          `      // that live in another partition. Because this slice consumes \`sourceId\``,
+          `      // without producing it, the framework infers the cross-partition read from`,
+          `      // the slice graph. Renaming it off \`*Id\` would silently drop that.`,
+          `      sourceId: string,`,
+          `      origin: origin,`,
           `    })`,
           `  // Reported by the send slice once the provider has settled.`,
           `  | @noApi ${n.recordCmd}({${id}: string, reference: string, providerRef: string})`,
@@ -226,21 +287,51 @@ let sliceSpec = (c: config): string => {
           `  | ${n.subscribed}({${id}: string, category: category, channel: channel})`,
           `  | ${n.unsubscribed}({${id}: string, category: category, channel: channel})`,
           `  // The addressed message. \`address\` is the snapshot delivery uses, which is`,
-          `  // why it is on the fact rather than looked up again later.`,
+          `  // why it is on the fact rather than looked up again later — and why it stays`,
+          `  // here and off the delivery view: the record of where a message actually went`,
+          `  // belongs in the log an investigation reads, not in a general read model.`,
           `  | ${n.requested}({`,
           `      ${id}: string,`,
           `      category: category,`,
           `      reference: string,`,
           `      channel: channel,`,
           `      address: string,`,
+          `      subjectType: string,`,
+          `      subjectRef: string,`,
           `      subject: string,`,
           `      body: string,`,
+          `      // What was in force when this went out — a message should record why.`,
+          `      origin: origin,`,
           `    })`,
           `  // Two different ways to send nothing. A ${c.noun->String.toLowerCase} who declined is the`,
           `  // system working; one with no address for a channel they enabled is the system`,
           `  // falling short, and one fact for both hides every gap behind a preference.`,
-          `  | ${n.suppressed}({${id}: string, category: category, reference: string})`,
-          `  | ${n.undeliverable}({${id}: string, category: category, reference: string})`,
+          `  | ${n.suppressed}({`,
+          `      ${id}: string,`,
+          `      category: category,`,
+          `      reference: string,`,
+          `      subjectType: string,`,
+          `      subjectRef: string,`,
+          `      origin: origin,`,
+          `    })`,
+          `  | ${n.undeliverable}({`,
+          `      ${id}: string,`,
+          `      category: category,`,
+          `      reference: string,`,
+          `      subjectType: string,`,
+          `      subjectRef: string,`,
+          `      origin: origin,`,
+          `    })`,
+          `  // The third way of not sending: another producer owns this source. Its own`,
+          `  // fact for the same reason the two above are two — and load-bearing besides,`,
+          `  // because the relay resolves its TODO row on an outcome, and without this one`,
+          `  // a deferred request retries its whole budget and is abandoned silently.`,
+          `  //`,
+          `  // \`sourceKey\` and not \`sourceId\`, and this is the one place the two names`,
+          `  // differ: a produced \`sourceId\` here would give this slice two candidate`,
+          `  // partitions and stop \`sourceId\` counting as consumed-but-not-produced, which`,
+          `  // is what makes the claim read cross partitions at all.`,
+          `  | ${n.deferred}({${id}: string, reference: string, sourceKey: string})`,
           `  | ${n.delivered}({${id}: string, reference: string, providerRef: string})`,
           `  | ${n.failed}({${id}: string, reference: string, reason: string})`,
           ``,
@@ -336,44 +427,86 @@ let sliceBehavior = (c: config): string => {
           `    state->Rules.evolve(`,
           `      Unsubscribed({category: categoryKey(category), channel: channelKey(channel)}),`,
           `    )`,
+          `  // Read across partitions from ${n.claims} — see the source field on`,
+          `  // \`${n.requestCmd}\`.`,
+          `  | ${n.claimed}({sourceId, by}) => state->Rules.evolve(Claimed({source: sourceId, by}))`,
+          `  | ${n.released}({sourceId}) => state->Rules.evolve(Released({source: sourceId}))`,
           `  }`,
           ``,
           `// The trait decides; this names what it decided in the host's vocabulary.`,
+          `//`,
+          `// \`option\` because two of the trait's facts belong to ${n.claims}: this`,
+          `// component reads them and never writes them, so it has no event to name them`,
+          `// with.`,
           `let named = (${id}, fact: Rules.fact) =>`,
           `  switch fact {`,
-          `  | Announced({address}) => ${n.announced}({${id}: ${id}, ${c.contactField}: address})`,
+          `  | Claimed(_)`,
+          `  | Released(_) => None`,
+          `  | Deferred({reference, source}) =>`,
+          `    Some(${n.deferred}({${id}: ${id}, reference, sourceKey: source}))`,
+          `  | Announced({address}) =>`,
+          `    Some(${n.announced}({${id}: ${id}, ${c.contactField}: address}))`,
           `  | Subscribed({category, channel}) =>`,
-          `    ${n.subscribed}({`,
-          `      ${id}: ${id},`,
-          `      category: categoryOf(category),`,
-          `      channel: channelOf(channel),`,
-          `    })`,
+          `    Some(`,
+          `      ${n.subscribed}({`,
+          `        ${id}: ${id},`,
+          `        category: categoryOf(category),`,
+          `        channel: channelOf(channel),`,
+          `      }),`,
+          `    )`,
           `  | Unsubscribed({category, channel}) =>`,
-          `    ${n.unsubscribed}({`,
-          `      ${id}: ${id},`,
-          `      category: categoryOf(category),`,
-          `      channel: channelOf(channel),`,
-          `    })`,
+          `    Some(`,
+          `      ${n.unsubscribed}({`,
+          `        ${id}: ${id},`,
+          `        category: categoryOf(category),`,
+          `        channel: channelOf(channel),`,
+          `      }),`,
+          `    )`,
           `  | Requested({category, reference, channel, address}) =>`,
-          `    ${n.requested}({`,
-          `      ${id}: ${id},`,
-          `      category: categoryOf(category),`,
-          `      reference,`,
-          `      channel: channelOf(channel),`,
-          `      address,`,
-          `      // Carried on the command and put back below: the trait holds no sentence.`,
-          `      subject: "",`,
-          `      body: "",`,
-          `    })`,
+          `    Some(`,
+          `      ${n.requested}({`,
+          `        ${id}: ${id},`,
+          `        category: categoryOf(category),`,
+          `        reference,`,
+          `        channel: channelOf(channel),`,
+          `        address,`,
+          `        // Carried on the command and put back below: the trait holds no`,
+          `        // sentence, refuses to know what an occurrence is, and has no opinion`,
+          `        // about which rule asked.`,
+          `        subjectType: "",`,
+          `        subjectRef: "",`,
+          `        subject: "",`,
+          `        body: "",`,
+          `        origin: Default,`,
+          `      }),`,
+          `    )`,
           `  | Suppressed({category, reference}) =>`,
-          `    ${n.suppressed}({${id}: ${id}, category: categoryOf(category), reference})`,
+          `    Some(`,
+          `      ${n.suppressed}({`,
+          `        ${id}: ${id},`,
+          `        category: categoryOf(category),`,
+          `        reference,`,
+          `        subjectType: "",`,
+          `        subjectRef: "",`,
+          `        origin: Default,`,
+          `      }),`,
+          `    )`,
           `  | Undeliverable({category, reference}) =>`,
-          `    ${n.undeliverable}({${id}: ${id}, category: categoryOf(category), reference})`,
+          `    Some(`,
+          `      ${n.undeliverable}({`,
+          `        ${id}: ${id},`,
+          `        category: categoryOf(category),`,
+          `        reference,`,
+          `        subjectType: "",`,
+          `        subjectRef: "",`,
+          `        origin: Default,`,
+          `      }),`,
+          `    )`,
           `  }`,
           ``,
           `let through = (state, ${id}, op) =>`,
           `  switch state->Rules.decide(op, ~posture) {`,
-          `  | Ok(facts) => Ok(facts->Array.map(named(${id}, _)))`,
+          `  | Ok(facts) => Ok(facts->Array.filterMap(named(${id}, _)))`,
           `  | Error(#RecipientUnknown) => Error(${n.unknownError})`,
           `  }`,
           ``,
@@ -394,14 +527,44 @@ let sliceBehavior = (c: config): string => {
           `      Unsubscribe({category: categoryKey(category), channel: channelKey(channel)}),`,
           `    )`,
           ``,
-          `  // The one arm that is not a rename: the words belong to the requester, and the`,
-          `  // trait's fact does not carry them, so they are put back on the way out.`,
-          `  | ${n.requestCmd}({${id}, category, reference, subject, body}) =>`,
-          `    through(state, ${id}, Request({category: categoryKey(category), reference}))`,
-          `    ->Result.map(events =>`,
+          `  // The one arm that is not a rename: the words and the subject belong to the`,
+          `  // requester and the trait's facts carry neither, so both are put back on the`,
+          `  // way out. All three outcomes get the subject — what a suppressed or`,
+          `  // undeliverable notification was about is what makes those rows worth reading.`,
+          `  | ${n.requestCmd}({`,
+          `      ${id},`,
+          `      category,`,
+          `      reference,`,
+          `      subjectType,`,
+          `      subjectRef,`,
+          `      subject,`,
+          `      body,`,
+          `      sourceId,`,
+          `      origin,`,
+          `    }) =>`,
+          `    through(`,
+          `      state,`,
+          `      ${id},`,
+          `      Request({`,
+          `        category: categoryKey(category),`,
+          `        reference,`,
+          `        source: sourceId,`,
+          `        // The trait needs only which of the two yields to a claim; which rule`,
+          `        // it was is this host's fact, put back below.`,
+          `        origin: switch origin {`,
+          `        | Default => Default`,
+          `        | Configured(_) => Configured`,
+          `        },`,
+          `      }),`,
+          `    )->Result.map(events =>`,
           `      events->Array.map(event =>`,
           `        switch event {`,
-          `        | ${n.requested}(fields) => ${n.requested}({...fields, subject, body})`,
+          `        | ${n.requested}(fields) =>`,
+          `          ${n.requested}({...fields, subjectType, subjectRef, subject, body, origin})`,
+          `        | ${n.suppressed}(fields) =>`,
+          `          ${n.suppressed}({...fields, subjectType, subjectRef, origin})`,
+          `        | ${n.undeliverable}(fields) =>`,
+          `          ${n.undeliverable}({...fields, subjectType, subjectRef, origin})`,
           `        | other => other`,
           `        }`,
           `      )`,
@@ -421,6 +584,102 @@ let sliceBehavior = (c: config): string => {
   )
 }
 
+// ── The claims slice ─────────────────────────────────────────────────────────
+//
+// Its own component, and that is forced rather than preferred: a slice's DCB
+// partition is derived from the `*Id` fields its own events declare, so one slice
+// producing both recipient facts and source facts has two candidate partitions
+// and resolves to neither. Split, each side produces one key — and the reading
+// side then sees `sourceId` as a key it consumes without producing, which is
+// exactly the shape a cross-partition read is inferred from.
+
+let claimsSpec = (c: config): string => {
+  let n = namesOf(c)
+  lines([
+    `// ${n.claims} StateChangeSlice: which streams of occurrences a second`,
+    `// producer has taken over. One row per source, keyed by the source itself —`,
+    `// \`"<log>:<eventType>"\`, opaque to everyone but the producers that agree on it.`,
+    `//`,
+    `// Emitted by the trait; ordinary source from here on.`,
+    ``,
+    `@@reventless.spec`,
+    ``,
+    `@schema`,
+    `type consumedEvent =`,
+    `  | ${n.claimed}({sourceId: string, by: string})`,
+    `  | ${n.released}({sourceId: string})`,
+    ``,
+    `@schema`,
+    `type command =`,
+    `  // Relayed, never a client door — a caller who could claim a source would be`,
+    `  // silencing everybody else's notifications from it.`,
+    `  | @noApi ${n.claimCmd}({sourceId: string, by: string})`,
+    `  | @noApi ${n.releaseCmd}({sourceId: string})`,
+    ``,
+    `@schema`,
+    `type error =`,
+    `  // Both commands are idempotent, so there is no refusal to make. Declared`,
+    `  // because the shape requires one.`,
+    `  | ${n.claimError}`,
+    ``,
+    `@schema`,
+    `type event =`,
+    `  | ${n.claimed}({sourceId: string, by: string})`,
+    `  | ${n.released}({sourceId: string})`,
+    ``,
+    `let traits = [TraitNotification.Notification.declaration]`,
+    ``,
+  ])
+}
+
+let claimsBehavior = (c: config): string => {
+  let n = namesOf(c)
+  lines([
+    `@@reventless.behavior`,
+    ``,
+    `// The claim set is the trait's, folded through the same value the preferences`,
+    `// slice folds. Only the claim half is ever populated here.`,
+    `module Rules = TraitNotification.Notification_Rules`,
+    ``,
+    `type state = Rules.t`,
+    ``,
+    `let initialState = Rules.empty`,
+    ``,
+    `let evolve = (state, event: consumedEvent) =>`,
+    `  switch event {`,
+    `  | ${n.claimed}({sourceId, by}) => state->Rules.evolve(Claimed({source: sourceId, by}))`,
+    `  | ${n.released}({sourceId}) => state->Rules.evolve(Released({source: sourceId}))`,
+    `  }`,
+    ``,
+    `// No posture is consulted on either arm, so this table is never read. Passing`,
+    `// the trait's own decision function anyway keeps the idempotence rule in one`,
+    `// place rather than restating it here.`,
+    `let posture = (_category: string, _channel: Rules.channel) => false`,
+    ``,
+    `let named = (fact: Rules.fact) =>`,
+    `  switch fact {`,
+    `  | Claimed({source, by}) => Some(${n.claimed}({sourceId: source, by}))`,
+    `  | Released({source}) => Some(${n.released}({sourceId: source}))`,
+    `  // The other facts belong to the preferences slice; the two commands below`,
+    `  // cannot reach them.`,
+    `  | _ => None`,
+    `  }`,
+    ``,
+    `let through = (state, op) =>`,
+    `  switch state->Rules.decide(op, ~posture) {`,
+    `  | Ok(facts) => Ok(facts->Array.filterMap(named))`,
+    `  | Error(#RecipientUnknown) => Error(${n.claimError})`,
+    `  }`,
+    ``,
+    `let decide = (state, command) =>`,
+    `  switch command {`,
+    `  | ${n.claimCmd}({sourceId, by}) => through(state, Claim({source: sourceId, by}))`,
+    `  | ${n.releaseCmd}({sourceId}) => through(state, Release({source: sourceId}))`,
+    `  }`,
+    ``,
+  ])
+}
+
 // ── The send slice ───────────────────────────────────────────────────────────
 
 let sendSpec = (c: config): string => {
@@ -622,6 +881,11 @@ let conformanceBinding = (c: config): string => {
     `    ${n.subscribed}({${id}: ${id}, category, channel: Behavior.channelOf(channel)})`,
     `  let unsubscribedC = (category, channel): Spec.consumedEvent =>`,
     `    ${n.unsubscribed}({${id}: ${id}, category, channel: Behavior.channelOf(channel)})`,
+    `  // Written by ${n.claims} and read here across partitions — this slice`,
+    `  // consumes them and produces neither.`,
+    `  let claimedC = (source, by): Spec.consumedEvent =>`,
+    `    ${n.claimed}({sourceId: source, by})`,
+    `  let releasedC = (source): Spec.consumedEvent => ${n.released}({sourceId: source})`,
     ``,
     `  let announce = ${c.contactField} =>`,
     `    Spec.${n.announceCmd}({${id}: ${id}, ${c.contactField}: ${c.contactField}})`,
@@ -629,37 +893,86 @@ let conformanceBinding = (c: config): string => {
     `    Spec.${n.subscribeCmd}({${id}: ${id}, category, channel: Behavior.channelOf(channel)})`,
     `  let unsubscribe = (category, channel) =>`,
     `    Spec.${n.unsubscribeCmd}({${id}: ${id}, category, channel: Behavior.channelOf(channel)})`,
-    `  // The wording is this host's and the trait carries none, so the suite supplies`,
-    `  // whatever it likes and asserts nothing about it.`,
-    `  let request = (category, reference) =>`,
+    `  // The wording and the subject are this host's and the trait carries neither, so`,
+    `  // the suite supplies whatever it likes and asserts nothing about them.`,
+    `  //`,
+    `  // One source nothing ever claims, so every assertion that predates the handover`,
+    `  // keeps deciding exactly as it did.`,
+    `  let defaultSource = "TODO(graft)DcbEventLog:${c.occurrence}"`,
+    ``,
+    `  let requestFrom = (category, reference, ~source, ~origin) =>`,
     `    Spec.${n.requestCmd}({`,
     `      ${id}: ${id},`,
     `      category,`,
     `      reference,`,
+    `      subjectType: "${subjectTypeOf(c)}",`,
+    `      subjectRef: "subject-1",`,
     `      subject: "subject",`,
     `      body: "body",`,
+    `      sourceId: source,`,
+    `      origin: switch (origin: TraitNotification.Notification_Rules.origin) {`,
+    `      | Default => Default`,
+    `      | Configured => Configured({ruleId: "rule-1", ruleVersion: "1"})`,
+    `      },`,
     `    })`,
     ``,
+    `  let request = (category, reference) =>`,
+    `    requestFrom(category, reference, ~source=defaultSource, ~origin=Default)`,
+    ``,
     `  let announced = ${c.contactField} =>`,
     `    Spec.${n.announced}({${id}: ${id}, ${c.contactField}: ${c.contactField}})`,
     `  let subscribed = (category, channel) =>`,
     `    Spec.${n.subscribed}({${id}: ${id}, category, channel: Behavior.channelOf(channel)})`,
     `  let unsubscribed = (category, channel) =>`,
     `    Spec.${n.unsubscribed}({${id}: ${id}, category, channel: Behavior.channelOf(channel)})`,
-    `  let requested = (category, reference, channel, address) =>`,
+    `  let requestedWith = (category, reference, channel, address, origin) =>`,
     `    Spec.${n.requested}({`,
     `      ${id}: ${id},`,
     `      category,`,
     `      reference,`,
     `      channel: Behavior.channelOf(channel),`,
     `      address,`,
+    `      subjectType: "${subjectTypeOf(c)}",`,
+    `      subjectRef: "subject-1",`,
     `      subject: "subject",`,
     `      body: "body",`,
+    `      origin,`,
     `    })`,
+    ``,
+    `  let requested = (category, reference, channel, address) =>`,
+    `    requestedWith(category, reference, channel, address, Spec.Default)`,
+    `  // Which rule asked is this host's own shape, so the trait cannot build this.`,
+    `  let requestedConfigured = (category, reference, channel, address) =>`,
+    `    requestedWith(`,
+    `      category,`,
+    `      reference,`,
+    `      channel,`,
+    `      address,`,
+    `      Spec.Configured({ruleId: "rule-1", ruleVersion: "1"}),`,
+    `    )`,
+    `  let deferred = (reference, source) =>`,
+    `    Spec.${n.deferred}({${id}: ${id}, reference, sourceKey: source})`,
+    `  // The subject rides through the two decisions not to send as well: what a`,
+    `  // suppressed or undeliverable notification was about is the whole reason those`,
+    `  // rows are worth reading.`,
     `  let suppressed = (category, reference) =>`,
-    `    Spec.${n.suppressed}({${id}: ${id}, category, reference})`,
+    `    Spec.${n.suppressed}({`,
+    `      ${id}: ${id},`,
+    `      category,`,
+    `      reference,`,
+    `      subjectType: "${subjectTypeOf(c)}",`,
+    `      subjectRef: "subject-1",`,
+    `      origin: Spec.Default,`,
+    `    })`,
     `  let undeliverable = (category, reference) =>`,
-    `    Spec.${n.undeliverable}({${id}: ${id}, category, reference})`,
+    `    Spec.${n.undeliverable}({`,
+    `      ${id}: ${id},`,
+    `      category,`,
+    `      reference,`,
+    `      subjectType: "${subjectTypeOf(c)}",`,
+    `      subjectRef: "subject-1",`,
+    `      origin: Spec.Default,`,
+    `    })`,
     ``,
     `  let recipientUnknown = Spec.${n.unknownError}`,
     ``,
@@ -777,8 +1090,14 @@ let intakeRelayPatch = (c: config): patch => {
       ``,
       `@@reventless.spec`,
       ``,
+      `// The row a rule composes from. It carries the rule's id rather than a kind of`,
+      `// occurrence: the rule holds the category, the subject and the wording, so a`,
+      `// second notifiable event is a second entry in the table next door.`,
+      `//`,
+      `// It is also the payload the wording is rendered against, so every field here`,
+      `// is a path a template may name — \`{{ ${c.occurrenceId} }}\`.`,
       `@schema`,
-      `type todoItem = {${id}: string, ${c.occurrenceId}: string}`,
+      `type todoItem = {ruleId: string, ${id}: string, ${c.occurrenceId}: string}`,
       ``,
       `@schema`,
       `type command =`,
@@ -786,8 +1105,12 @@ let intakeRelayPatch = (c: config): patch => {
       `    ${id}: string,`,
       `    category: ${n.slice}.category,`,
       `    reference: string,`,
+      `    subjectType: string,`,
+      `    subjectRef: string,`,
       `    subject: string,`,
       `    body: string,`,
+      `    sourceId: string,`,
+      `    origin: ${n.slice}.origin,`,
       `  })`,
       ``,
       `let maxRetries = 3`,
@@ -798,9 +1121,7 @@ let intakeRelayPatch = (c: config): patch => {
       ``,
       `@@reventless.automation`,
       ``,
-      `// A TODO id is also the reference the request carries, so the outcome event`,
-      `// echoes back exactly what resolves the row.`,
-      `let key = ${c.occurrenceId} => \`notify:\${${c.occurrenceId}}\``,
+      `module Rule = TraitNotification.Notification_Rule`,
       ``,
       `module DcbSource = {`,
       `  // MUST equal "<pluginName>DcbEventLog".`,
@@ -814,32 +1135,73 @@ let intakeRelayPatch = (c: config): patch => {
       `    | ${n.requested}({reference: string})`,
       `    | ${n.suppressed}({reference: string})`,
       `    | ${n.undeliverable}({reference: string})`,
+      `    // The fourth is not a nicety: an unresolved row retries its whole budget`,
+      `    // and lands in \`onExhausted\`, so a handover would look like a slow failure`,
+      `    // with nothing in the log to explain it.`,
+      `    | ${n.deferred}({reference: string})`,
       `}`,
       ``,
+      `// TODO(graft): the wording. A trait declares the kind; what the sentence says`,
+      `// is this host's — and it is text rather than ReScript, rendered against the`,
+      `// todo item next door, so \`{{ ${c.occurrenceId} }}\` is a field of it.`,
+      `//`,
+      `// A rule's id is also the namespace of the references it writes, so two rules`,
+      `// on one subject are two notifications and two delivery rows.`,
+      `let defaultRules: array<Rule.t> = [`,
+      `  {`,
+      `    id: "${c.occurrence}",`,
+      `    version: "1",`,
+      `    source: {log: DcbSource.name, eventType: "${c.occurrence}"},`,
+      `    filter: Always,`,
+      `    category: "${c.occurrenceCategory}",`,
+      `    delivery: Immediate,`,
+      `    recipientPath: "${id}",`,
+      `    subjectType: "${subjectTypeOf(c)}",`,
+      `    subjectPath: "${c.occurrenceId}",`,
+      `    content: [{locale: "en", subject: "TODO(graft)", body: "TODO(graft)"}],`,
+      `  },`,
+      `]`,
+      ``,
+      `// The dispatch is the table's, so the switch below only takes an event apart.`,
+      `// Two rules on one event type are two notifications, with no arm to add.`,
+      `//`,
+      `// Only the immediate half of the table: a digest rule's occurrences are`,
+      `// gathered by the component that sends the digest, so no row is opened here.`,
+      `let todosFor = (~eventType, ~${id}, ~${c.occurrenceId}) =>`,
+      `  defaultRules`,
+      `  ->Rule.forEvent(~log=DcbSource.name, ~eventType)`,
+      `  ->Array.filter(Rule.isImmediate)`,
+      `  ->Array.map(rule => (`,
+      `    Rule.reference(rule, ~subject=${c.occurrenceId}),`,
+      `    ({ruleId: rule.id, ${id}: ${id}, ${c.occurrenceId}: ${c.occurrenceId}}: ${n.intake}.todoItem),`,
+      `  ))`,
+      ``,
       `module FromDcb = Mapping.Make(`,
       `  DcbSource,`,
       `  ${n.intake},`,
       `  {`,
       `    open DcbSource`,
       ``,
-      `    let collect = (event, _ctx) =>`,
+      `    let collect = (event, ~sourceId as _, _ctx) =>`,
       `      switch event {`,
-      `      | ${c.occurrence}({${c.occurrenceId}, ${c.occurrenceRecipient}}) => [`,
-      `          (`,
-      `            key(${c.occurrenceId}),`,
-      `            ({${id}: ${c.occurrenceRecipient}, ${c.occurrenceId}: ${c.occurrenceId}}: ${n.intake}.todoItem),`,
-      `          ),`,
-      `        ]`,
+      `      | ${c.occurrence}({${c.occurrenceId}, ${c.occurrenceRecipient}}) =>`,
+      `        todosFor(`,
+      `          ~eventType="${c.occurrence}",`,
+      `          ~${id}=${c.occurrenceRecipient},`,
+      `          ~${c.occurrenceId},`,
+      `        )`,
       `      | ${n.requested}(_)`,
       `      | ${n.suppressed}(_)`,
-      `      | ${n.undeliverable}(_) => []`,
+      `      | ${n.undeliverable}(_)`,
+      `      | ${n.deferred}(_) => []`,
       `      }`,
       ``,
       `    let resolve = event =>`,
       `      switch event {`,
       `      | ${n.requested}({reference})`,
       `      | ${n.suppressed}({reference})`,
-      `      | ${n.undeliverable}({reference}) =>`,
+      `      | ${n.undeliverable}({reference})`,
+      `      | ${n.deferred}({reference}) =>`,
       `        Some(reference)`,
       `      | ${c.occurrence}(_) => None`,
       `      }`,
@@ -848,19 +1210,41 @@ let intakeRelayPatch = (c: config): patch => {
       ``,
       `let mappings: array<module(Mapping)> = [module(FromDcb)]`,
       ``,
-      `// TODO(graft): the wording. A trait declares the kind; what the sentence says`,
-      `// is this host's, and a config field for it would be a template language.`,
       `let process = (id, item: ${n.intake}.todoItem) =>`,
-      `  Some((`,
-      `    item.${id},`,
-      `    ${n.intake}.${n.requestCmd}({`,
-      `      ${id}: item.${id},`,
-      `      category: ${c.occurrenceCategory},`,
-      `      reference: id,`,
-      `      subject: "TODO(graft)",`,
-      `      body: "TODO(graft)",`,
-      `    }),`,
-      `  ))`,
+      `  // Two ways the table can have moved under a row that was already open: the`,
+      `  // rule is gone, or it has become a digest's. Neither publishes anything, and`,
+      `  // either leaves the row Pending — a \`None\` here spends no retry budget, so it`,
+      `  // is re-swept on every batch and never reaches \`onExhausted\`.`,
+      `  switch defaultRules->Rule.byId(item.ruleId)->Option.filter(Rule.isImmediate) {`,
+      `  | None => None`,
+      `  | Some(rule) =>`,
+      `    let payload = item->Reventless.Util_Sury.toJson(${n.intake}.todoItemSchema)`,
+      `    switch (Rule.matches(rule.filter, ~payload), Rule.recipientOf(rule, ~payload)) {`,
+      `    | (false, _) | (_, None) => None`,
+      `    | (true, Some(${id})) =>`,
+      `      let (subject, body) =`,
+      `        Rule.compose(rule, ~payload, ~schema=${n.intake}.todoItemSchema)`,
+      `      Some((`,
+      `        ${id},`,
+      `        ${n.intake}.${n.requestCmd}({`,
+      `          ${id}: ${id},`,
+      `          category: ${n.slice}_Behavior.categoryOf(rule.category),`,
+      `          reference: id,`,
+      `          subjectType: rule.subjectType,`,
+      `          subjectRef: Rule.subjectOf(rule, ~payload),`,
+      `          subject,`,
+      `          body,`,
+      `          // Which stream this came from. A second producer claims exactly this`,
+      `          // string to take the entry over, so both sides must derive it the same`,
+      `          // way — the format is the whole agreement.`,
+      `          sourceId: Rule.sourceId(rule),`,
+      `          // This relay IS the compiled table, so every request it makes is the`,
+      `          // default one — the arm that yields when somebody claims the source.`,
+      `          origin: Default,`,
+      `        }),`,
+      `      ))`,
+      `    }`,
+      `  }`,
       ``,
       `// A relay that gave up published no command, so the competency never heard of`,
       `// the occurrence — a delivery-failed fact for a message nobody requested would`,
@@ -882,6 +1266,11 @@ let emit = (~config: config, ~into: string, ~tests: string): output => {
     files: [
       {path: `${into}/StateChangeSlice/${n.slice}.res`, contents: sliceSpec(config)},
       {path: `${into}/StateChangeSlice/${n.slice}_Behavior.res`, contents: sliceBehavior(config)},
+      {path: `${into}/StateChangeSlice/${n.claims}.res`, contents: claimsSpec(config)},
+      {
+        path: `${into}/StateChangeSlice/${n.claims}_Behavior.res`,
+        contents: claimsBehavior(config),
+      },
       {path: `${into}/OutboundTranslationSlice/${n.send}.res`, contents: sendSpec(config)},
       {
         path: `${into}/OutboundTranslationSlice/${n.send}_Translation.res`,