Aller au contenu

Sense 41: The Relevance — Which Rings Are For You

Ce contenu n’est pas encore disponible dans votre langue.

Sense 41 · Forming · Last touched 2026-07-27

  • last_verified: 2026-07-27

Synced from docs/design/sense_41_the_relevance.md in the engine repo — that’s the source; this page is a build-time mirror.

Severity says how loud. Capability says who may act. Relevance answers the question the other two leave open: who is this for?

The Bell (Sense 33) gave us a notification substrate where five source plugins produce rings into a single per-tenant Inbox. Today, every ring with a view:bell audience sees every other ring’s content — capability gates whether you can read, but not what is for you. As tenants grow past a single analyst, this collapses. A CFO opening the Inbox sees 60 action-cell rings about data-engineering TODOs and four validity-cluster rings about silver-table edge cases; the wisdom about Q3 spending that actually matters to them sits buried in the middle of operational noise.

Sense 41 names the missing dimension and proposes a thin layer that adds it on top of the existing substrate.


DimensionQuestion it answersWhere it lives
SeverityHow loud is this?The severity column on the ring (alarm / concern / heads_up / info)
CapabilityMay you read it? May you act on it?Sense 25 passes (view:bell / act:bell)
Relevance (new)Is this for you specifically?Missing today — every ring is for everyone

Severity is universal — “this is loud” means the same thing to every viewer. Capability is binary — you either may or may not act. Relevance is identity-keyed — the same ring can matter to one person and be operational noise to another, depending on what they do.

These three dimensions are orthogonal. A concern-severity ring visible to view:bell may be highly relevant to a Compensation analyst and irrelevant to the Compliance lead, even though both hold the capability and both see the same severity. Without a relevance axis, the Inbox has no way to honor that asymmetry.


Stop conflating exists in the tenant with belongs in everyone’s Inbox. The two collapse to the same answer in a one-or-two-person tenant; they diverge the moment roles diverge. Once that move is made, the rest drops out:

  1. Rings are tenant-scoped (unchanged). The notifications table holds one row per logical noticing; every viewer sees the same set when they choose to.
  2. Surfacing is identity-scoped (new). The default Inbox view filters by what’s relevant to the viewer; an explicit “show all” toggle returns the V1 behavior at a click.
  3. Resolutions remain tenant-scoped (Sense 33). If a CFO dismisses a ring, it stays dismissed for everyone — the resolution is an analytical judgment about the noticing itself, not a personal preference.

The first and third invariants are why this is a surfacing layer on top of Sense 33 and not a restructuring of the substrate.


One new field on the _<tenant>.notifications schema:

relevance VARCHAR -- JSON: {"roles": [...], "anchors": [...], "follows": [...]}

Each source plugin populates relevance with whatever it knows about who the ring matters to. The Inbox’s load query consumes the field together with the viewer’s identity (their roles, what they follow) and orders / filters accordingly. A NULL relevance means “no declared relevance” and falls into the V1-style “visible to all” default.

Three relevance signals, evaluated in priority order:

SignalSourceStrength
relevant_for: [role_id, ...]explicit, set by the plugin or audit YAMLstrongest — overrides the others
Anchor authorship / ownershipderived from the ring’s anchor_surface + anchor_target_idimplicit, no plugin change needed
Anchor follow / subscriptionthe viewer opted in by following an anchorimplicit, viewer-driven

The Inbox’s primary tab shows rings whose relevance matches the viewer; a Show all rings toggle reverts to the V1 view. Neither hides anything — the ring still exists for the tenant, the resolution state stays shared, the comments thread is the same thread.


Anchor-derived (implicit, V1 of the new layer)

Section titled “Anchor-derived (implicit, V1 of the new layer)”

Most rings already carry an anchor_surface + anchor_target_id pointing at the artifact the ring is about. Anchor-derived relevance turns those anchors into surfacing signals at read time:

  • A wisdom ring anchored at smebit_compensation_anomaly floats to the top of the Compensation analyst’s Inbox because they author smebits in the compensation category.
  • An action ring anchored at nb_q3_revenue_review surfaces for the finance team because the notebook is in their working set.
  • A validity ring anchored at silver_grants surfaces for the data-engineering role because they own silver-tier ingestion.

The implicit signal sources are already in the system:

  • Authorship: who wrote / last edited the anchor artifact (git blame on the AFS YAML)
  • Ownership: explicit owner: <role> field on the anchor’s registry row (when the artifact carries one)
  • Category membership: rings anchored at smebits in category X surface for roles tagged with that category in their identity tree

Anchor-derived is cheap because every signal already exists in the KLS or AFS; the Inbox just learns to weight rings by viewer.

When implicit signals aren’t enough — typically for rings that don’t have a natural anchor (cross-cutting compliance checks, diagnostic codes, tenant-wide alerts) — a plugin or audit YAML declares its relevance explicitly:

# in afs/audits/audit_compliance_q3_gap.yaml
audit_id: compliance_q3_gap
relevance:
roles: [compliance_officer, cfo]
trigger_query: |
SELECT 1 FROM ...
message: { ... }

The Inbox filters by intersection: a viewer sees the ring if any declared role is one of theirs. Multiple-role rings are an OR, not an AND — a ring relevant_for: [cfo, hr_director] shows in both audiences.

Explicit declarations override implicit anchor-derived weighting: once a ring carries relevance.roles, the Inbox honors that explicitly and doesn’t try to infer from the anchor.


  • Hide rings entirely. A Show all rings toggle lives in the Inbox header, persists in URL state. Filtering is the default surfacing, not a permission gate. Anyone with view:bell can see any ring they want; the filter is help, not control.
  • Replace severity. A concern ring is still concern-level regardless of who sees it. Relevance shapes the queue order; it doesn’t repaint the badge.
  • Fragment the resolution state. If a CFO dismisses a ring, it remains dismissed for everyone. Dismissal is an analytical claim about the ring’s status, not a personal mute. The viewer-personal preference equivalent is snooze (already in Sense 33 as the operational tier of the SIS).
  • Replace capability gating. A viewer without view:bell still sees no Inbox; a viewer without act:bell still sees no resolution buttons. Relevance composes with those gates; it doesn’t substitute for them.

  • Sense 25 (Identity & Passes) provides “who you are and what roles you hold.” The relevance filter reads from there at request time — no change to Sense 25’s contract, just a new consumer.
  • Sense 33 (The Bell) provides the ring substrate, the source plugins, the Inbox surface. Sense 41 adds one column to the notifications schema and a filter at the read path; the substrate, the durability tier split, the comment threads, the suggested- action vocabulary all stay unchanged.
  • Sense 38 (The Scribe) unaffected. When a viewer resolves, the YAML body still records actor: ; the deployment-side Scribe still commits. Relevance shapes what they saw to begin with; the Scribe shapes what their action looks like once taken.
  • Sense 18 (The Ledger) gains a richer audit trail: the Ledger can record which audiences a ring surfaced for, not just whether it was created. Useful when investigating “did anyone with role X ever see this?” after the fact.

Lives in the Inbox header. Default state OFF (filtered to relevance). Persists in URL state (?show=all) so it’s bookmarkable and shareable. Mostly used by:

  • Admins doing audit walks
  • Engineers investigating “is this ring visible to anyone?”
  • Cross-role viewers (CFO who also leads a project team and wants the project-team rings too) — though the better fix here is usually to add the second role to their identity, not to live in unfiltered mode

A small UI affordance on the entity-anchor page: a Follow this / Unfollow toggle that records the viewer’s interest in SIS.bell_follows (one row per (user, anchor) pair). The relevance filter consults this list. Operational tier — never flushed to AFS; following a smebit is calendar-shaped state, not analytical truth.

Cross-tenant pattern detection (forward pointer)

Section titled “Cross-tenant pattern detection (forward pointer)”

The packhub-side pack-view aggregator deferred in Sense 33 § Cross- tenant aggregation naturally extends here: relevance can be pack-level (“which roles across all tenants should see this pattern?”). Not in scope for Sense 41 V1 — flagged for the eventual pack-view design.


Not yet manifest in the engine. Status: proposed. See the implementation phases / open questions above for the path from this paper to running code.


  1. Default behavior for unannotated rings. A ring with no declared relevance and no obvious anchor relevance — should it surface to everyone (V1 fallback, no regression) or to no one (forcing explicit declarations)? My instinct: surface to everyone, to keep migration painless. Authors graduate rings into relevance-aware shape over time.

  2. Role definitions as pack vs tenant. Role IDs in relevance.roles need to be stable identifiers. They probably live in Sense 25’s identity tree, but at what scope? A pack defines a role set (“Compensation Analyst, Compliance Officer, …”), tenants instantiate them. Pack-level role-keyed rings reference pack-defined roles. Worth confirming when Sense 25 gets a Phase 2.

  3. Anchor-derived weight, not filter. Should anchor-derived relevance be a filter (you don’t see the ring unless you own the anchor) or a weight (you see all rings, ranked by anchor-relevance)? V1 instinct: weight, to avoid the silent-hide failure mode. The Inbox shows everything; relevant rings just surface first.

  4. Follow vs subscribe semantics. Are follows opt-in additions (“show me rings about smebit X even though I don’t own it”) or opt-out subtractions (“hide rings about anchor Y”)? V1: opt-in additions only; explicit mute lives on the resolution layer (snooze).

  5. How does this look in the cloud-Atelier? The cloud Inbox sees rings across multiple tenants. Relevance needs to compose across that surface too — possibly via Sense 39 or Sense 40’s framing (whichever ended up handling cross-tenant viewer identity).


  • The new relevance column — not yet on the notifications schema. First write lands when the V1 (anchor-derived) Inbox filter is wired.
  • SIS.bell_follows table — not yet created. Schema joins notes/bookmarks/recents/bell as a fifth orphan-branch artifact type if we want follows to survive across machines; or stays SIS-only if we treat them as operational like snoozes. Probably orphan-branch; following a smebit is a real preference worth carrying.
  • Anchor-derived weight implementation — needs the Inbox load to learn the viewer’s identity tree from Sense 25 at request time and rank rings accordingly.
  • Explicit relevant_for: plugin support — each source plugin (wisdom, data_gap, diagnostic, action, validity) needs to learn to honor a relevance: block in its respective source artifact (smebit registry, audit YAML, etc.).

The Bell tells you something happened. Severity tells you how loud. Capability tells you what you may do about it. Relevance tells you why you, in particular, should care.


Numerical neighbors: ← Sense 40: The Metamodel · Sense 42: The Landscape →

jazzisnow jinflow is a jazzisnow product
v0.65.0 · built 2026-11-13 10:20 UTC