V1 Web PWA · Walk result

Journey result: Quiet hours, verified channels, and provider boundaries

A dated evidence record for V1 Web PWA: observed behavior, current source reconciliation, automation evidence, and explicit proof limits.

verdict: partial· 2026-05-29
8sections26 minread1table

On this page
  • Walked: 2026-05-29 at bf12b0f7d8c291499e1df1ec75d4bd21acf3f6b1. The retained result reported a passing route walk through an ephemeral /tmp script; it did not preserve the script, raw report, browser trace, or provider evidence.
  • Re-reconciled: 2026-09-25 against be8d42dc82b (audit-remediation P2.b) by source review: the member's push, in-app and reminder-kind toggles now apply to reminders at send time. The reminders route, producer and event consumer suites and the messaging-channels cycle suite passed freshly; no browser suite was rerun. Only the reminder policy statements changed.
  • Re-reconciled: 2026-09-25 against a1593bd87c0 (audit-remediation P2.c) by source review: an external reminder now needs the member's consent; without it the reminder goes to the in-app inbox only. The reminders route and the messaging-channels planner and cycle suites passed freshly; no browser suite was rerun. The reminder policy statements and the worker-lease open question changed.
  • Re-reconciled: 2026-09-25 against 9918f396600 (audit-remediation P2.a) by source review: quiet hours now have one owner, the notification preferences snapshot, that every writer and reader uses; the consumer profile's flag is its seed and a mirror. The reminders route, message-center route, profile route, and Telegram rooms and reminders suites passed freshly; no browser suite was rerun. Only the quiet-hours authority statements changed.
  • Re-reconciled: 2026-09-27 against b1c8b38002c (audit-remediation P2.a, review of 9918f396600) by source review: a member's first notification write starts from the seed their current profile gives, after a restart too, and the profile route writes the quiet-hours toggle to the owner before it saves the profile and puts it back if that save fails. The reminders route suite passed freshly at 40 passed and the quiet-hours owner suite at 5 passed; no browser suite was rerun. Only the quiet-hours write-order and seed statements changed. A same-day correction after independent review reran the channel-binding delivery spec, ten cases since af30012bf8 added the WhatsApp no-template refusal, at 10 passed, and states what the web row shows for a pending binding.
  • Re-reconciled: 2026-09-25 against 016a0e2823e (audit-remediation P1.a and P1.b) by source review: the bind route now sends its code through the shared provider call and replies with what the provider did, and the web row's save message says a code was sent only when it was (corrected 2026-09-27: the row's pending text still reads "Code sent" for every pending binding). The nine-case channel-binding delivery spec passed freshly at 9 passed; no browser suite was rerun. Only the code-delivery statements changed.
  • Reconciled: 2026-07-18 against the current read-only summary, mutable profile controls, preference stores, channel-binding lifecycle and snapshot wire, durable message-center delay/replay path, Telegram HMAC routes and user-state snapshot, reminder worker, provider router, notification, reminder, message-center, and Telegram write-through/erasure suites, and all seven named Playwright specs. The message-center, channel-binding, and Telegram unit suites passed freshly at eleven, 21, and six cases; their real-Postgres cases each collected as one skip without a database URL. This was not a fresh application run.
  • Verdict: partial / deep for the shipped control planes — the current evidence deeply covers summary-to-editor handoff, quiet-hours and domain preference round trips, a non-production email/SMS/WhatsApp verification lifecycle, durable custom notification preferences, durable reminder schedule/inbox/erasure state, required restart-safe channel bindings, durable message-center delay and manual replay, safety bypass, exact profile/session/ message-continuity erasure and export, and restart-safe Telegram link, capture, preference, suppression, export, and erasure state. It does not prove that a sent code reached a real inbox or phone, production WhatsApp code delivery, an atomic toggle/window update, automatic message-center replay, genuine account step-up, identity convergence, or delivery to a profile-bound email/SMS/WhatsApp address.
  • Current authority: WALKTHROUGH/journeys/messages-quiet-hours-and-channel-binding.md defines the journey and partial outcome; that preserved tracker still describes the split quiet-hours authorities that audit-remediation P2.a replaced with one owner.

Result at a glance#

Interaction Proof · limit
Read-only summary and handoff Proof: ten browser cases cover the account-scoped four-channel, five-category projection, preference read-back, explicit failure copy, editor link, anonymous redirect, footer behavior, 390 px stacking, standalone mode, and real-service-worker replay. Limit: the page is a static projection; its server fetch collapses an unavailable or rejected response into an empty state.
Quiet-hours and domain editor Proof: five browser cases and twelve real-HTTP cases cover the natural two-write enable flow, start/end time, timezone, normalized weekday mask, digest cadence, all six domain matrices, auth, scope, and validation. The custom preference store now commits through a required database-backed snapshot. Limit: since audit-remediation P2.a the toggle and window share one owner every reader uses, but the editor still writes them as separate requests, so partial success can leave one changed without the other.
Email/SMS/WhatsApp binding Proof: two browser cases drive real BFF request, salted-hash pending state, preview-code verification, wrong-code persistence, secret-free reload, typed removal, 390 px controls, and service-worker behavior. Production requires the snapshot; request, verify, and unbind await candidate persistence. A 21-case unit suite proves verified/pending restart, rollback, race ordering, and erasure fences. Limit: the browser cases run without a provider, so they verify through the non-production preview code; the real-Postgres restart case is environment-gated.
Verification-code delivery Proof: the bind route sends the code through deliverWithEnvProviders (email through SendGrid, SMS through Twilio with STOP suppression) and replies delivery: sent only when the provider accepted it, otherwise its reason (provider-error for a transport failure or an 8 s timeout, suppressed, policy-blocked for a WhatsApp member language with no approved template, missing-config). A ten-case spec proves one send per bind carrying the code that verifies, with only the transport doubled, and that a member language with no approved WhatsApp template is refused before any Meta call. Limit: sent is the provider accepting the request, not a delivery receipt; the server constructs no WhatsApp sender, so production WhatsApp binds still answer missing-config.
Bound-address delivery Proof: current source maps verified binding fields into a reminder recipient, gates matching reminder channels on verified status, and awaits a durable reminder snapshot before acknowledging production schedules or cycles. Limit: automatic producers all choose push, so their copied email/SMS/WhatsApp fields are ignored; manually scheduled external reminders carry an independently supplied recipient. No named suite proves provider delivery to the stored profile address.
Quiet-hours dispatch Proof: the sixteen-case BFF suite covers non-essential delay, due replay, crisis-frame hold, incident bypass, and resulting inbox receipts over real HTTP. The required message-center snapshot preserves delayed work, inbox rows, receipts, and holds; failed replay persistence keeps work queued. Limit: replay is an explicit admin call without a timer or claim lease, and its sent/delivered stages are authored by the BFF rather than provider callbacks.
Telegram identity seam Proof: five real-BFF Login Widget/step-up cases verify a valid HMAC, two invalid HMAC forms, the non-sensitive scope set, and action classification; two of the 24 webhook-suite cases add Mini App HMAC rejection. A six-case unit suite proves write-before-publish link/capture state, rollback, restart, ordered erasure fences, and fail-closed production use; its one-case Postgres companion is environment-gated. Limit: the public Login Widget still mints an iris:<telegram-id> subject rather than one of the three profile rows, so this does not prove convergence with a signed-in profile or bot-provider delivery.
Removal Proof: a verified row rejects DELETE without the literal channel-revoke header value, then awaits a durable unbound projection. Account deletion durably erases/fences the exact profile channel bindings, Telegram profile/captures, custom preferences, device sessions/tokens, notification read state, reminder continuity, and message-center partition; profile, saved-content, and session exports include the corresponding records. Limit: the phrase is client-known confirmation, not primary-credential step-up, and removing one profile channel invokes none of the other erasers or provider, Telegram, device-token, or chat cleanup.

Evidence map#

This vertical authority ledger keeps three independent planes separate. Solid edges are exercised by the named application suites; dashed edges mark the production meaning still missing. The stacked lanes are reading order, not a claim that profile binding, message-center replay, and Telegram call one another.

FlowchartFlowchart: 8 steps and 5 connections.missingmissingseparateProfile summary andmutable editorDurable binding snapshotplus provider send orpreviewProvider receipt, WhatsAppsender, and bound-addressdeliveryOne quiet-hours owner inthe durable preferencesnapshotMessage policy, durabledelay, and admin replayMessage-center timer,claim lease, and providercallbackDurable Telegram HMACidentity and user stateProfile binding inventory
Flowchart: Flowchart. Flowchart: 8 steps and 5 connections.

Drawn from its Mermaid source.

As text
Parts:
- Profile summary and mutable editor
- Durable binding snapshot plus provider send or preview
- Provider receipt, WhatsApp sender, and bound-address delivery
- One quiet-hours owner in the durable preference snapshot
- Message policy, durable delay, and admin replay
- Message-center timer, claim lease, and provider callback
- Durable Telegram HMAC identity and user state
- Profile binding inventory

Connections:
- Profile summary and mutable editor to Durable binding snapshot plus provider send or preview
- Durable binding snapshot plus provider send or preview to Provider receipt, WhatsApp sender, and bound-address delivery (dotted): missing
- One quiet-hours owner in the durable preference snapshot to Message policy, durable delay, and admin replay
- Message policy, durable delay, and admin replay to Message-center timer, claim lease, and provider callback (dotted): missing
- Durable Telegram HMAC identity and user state to Profile binding inventory (dotted): separate
Show source
flowchart TB
    A[Profile summary and mutable editor] --> B[Durable binding snapshot plus provider send or preview]
    B -. missing .-> C[Provider receipt, WhatsApp sender, and bound-address delivery]
    C ~~~ D[One quiet-hours owner in the durable preference snapshot]
    D --> E[Message policy, durable delay, and admin replay]
    E -. missing .-> F[Message-center timer, claim lease, and provider callback]
    F ~~~ G[Durable Telegram HMAC identity and user state]
    G -. separate .-> H[Profile binding inventory]

Proven observations#

The historical pass remains a dated route observation, not the current grade#

  • The old result observed /profile/notifications, four channels, four categories, and no feature-flag rate limit. The current BFF projection has four channels and five categories after adding the Arete weekly-review row, so the historical count is no longer a product contract.
  • The current ten-case index spec proves more than the old walker: account-email read-back, master push reflection, Arete reminder reflection, fail-closed empty copy, editor navigation, anonymous redirect, touch-safe footer targets, phone stacking, standalone mode, and an actual service-worker document replay.
  • That suite still does not recover the historical raw walk or rerun the feature-flag premise. The old zero-error and zero-failure statements therefore remain dated observations at the walked commit.

The summary and editor expose two different jobs#

  • /profile/notifications is a server-rendered, read-only projection of channels and categories. “Change delivery settings” opens /profile?path=notifications, where the notification matrix and quiet-hours controls live. The email/SMS/WhatsApp binding rows live in the broader profile settings panel, not in /messages and not as switches on the summary page.
  • The summary's four channels are email, push, SMS, and Telegram. They are not the same inventory as GET /v1/profile/channels, whose bindable set is exactly email, SMS, and WhatsApp. A summary label therefore cannot be read as a verified binding or transport capability.
  • A null BFF read becomes zero channels and zero categories with explicit recovery copy. That is honest about the unavailable projection, but it does not distinguish authentication rejection, network failure, malformed data, and a legitimately empty account.

The profile binding lifecycle is real, secret-safe, and sends its code#

  • The bind route is user-scoped and abuse-protected. It accepts only email, SMS, or WhatsApp, generates a six-digit code, stores a salted hash with TTL and attempt state, and returns a secret-free binding projection. The plaintext code is not persisted.
  • The route sends the minted code through deliverWithEnvProviders, the provider selection every other outbound message uses: email through SendGrid when OSHUN_SENDGRID_API_KEY and OSHUN_MESSAGING_EMAIL_FROM are set, SMS through Twilio when OSHUN_TWILIO_* are set, honouring STOP suppression. It replies delivery: sent only when the provider accepted the message; otherwise it replies with the provider's reason. A transport failure, a thrown fetch, or no answer within 8 s is provider-error, never missing-config, and the provider's response body stays in the server log.
  • WhatsApp takes its sender only from the route's own construction, never from request data or environment keys. The server constructs none, so a WhatsApp bind answers missing-config in production until a reviewed sender exists (task 14.2).
  • Only when no provider is configured does a non-production server return delivery: preview with the code. A production bind without a provider returns missing-config and no code. The save message says a code was sent only for sent (preview and missing-config say delivery is not configured; suppressed and failures show an error on the row), but the row's pending text reads "Code sent to <address>. Enter it below to confirm." for every pending binding, including one whose send reported missing-config.
  • The ten-case delivery spec drives the real route and provider selection with only the transport doubled: exactly one SendGrid, Twilio, or Meta send per successful bind, each carrying the code that then verifies; missing-config without a provider and no transport call; preview only outside production; provider-error for a transport failure; suppressed for a number that sent STOP; inert WhatsApp environment keys; and a WhatsApp bind for a member whose language has no approved template (Portuguese, French) refused before any Meta call as policy-blocked, with no code and the binding left pending.
  • Verify distinguishes verified, wrong-code, expired, locked, and not-pending as 200 outcomes for an existing row; only an absent binding is a 404. The UI can therefore preserve a pending row and explain an incorrect code instead of collapsing it into a generic request error.
  • The two-case browser suite performs the complete preview-code email lifecycle against real HTTP, reloads the full route after verification and removal, proves a wrong SMS code remains pending, and checks every affected control at a 390 px viewport for 44 px targets and zero page overflow. It does not stop and restart the BFF.
  • Deployable startup calls requireDurableChannelBindings and hydrates the snapshot before traffic. Bind, confirm, and unbind clone the last committed state, serialize mutation, persist, then publish; persistence failure maps to 503, an erased subject to 409, and neither a new address nor a burned verification attempt leaks into the visible view.
  • The 21-case focused store suite proves authoritative-empty boot, verified and pending-code restart recovery, user isolation, failed-write rollback, exact-subject erasure, adjacent-user preservation, both stale-mutation race orders, failed-deletion rollback, and fail-closed missing-sink behavior. Its one-case real-Postgres companion repeats verified-state restart and a signed profile erasure fence, but collected as skipped here without a database URL.
  • The profile export includes the secret-safe binding record, revision, and statuses. Account-level profile deletion composes the binding eraser; a successful fence rejects stale requests after restart without deleting an adjacent subject.

Quiet hours have one owner, written by a non-atomic editor#

  • Since audit-remediation P2.a, the notification preferences snapshot owns quiet hours: time, timezone, weekday mask, and whether they are on, beside digest settings, six domain records, and persona records with per-subject revisions and deletion fences. Telegram /quiet, PATCH /v1/notifications/preferences, and /v1/preferences write it. The profile route writes quietHoursEnabled to a stored record first and saves the consumer profile second: a failed first write changes neither store, and if the profile save fails the route puts the stored value back, only while the record is still at the revision it wrote, so a later change stands.
  • The reminder worker, the message-center dispatch route, the preference GET and PATCH responses, the profile preferences payload, Telegram /settings and its reminder check, and the assistant's behavior profile all read that owner through one function, with no overlay. The consumer profile's quietHoursEnabled is the store's seed for a member who never saved notification preferences, so their derived timezone and digest cadence keep following the profile; otherwise it is a mirror nothing reads for delivery. A first write of notification preferences (the PATCH, Telegram /quiet or /timezone) starts from the seed their current profile gives, read when the write runs, so a restart that empties the derived cache cannot make it persist server defaults or the server timezone.
  • The natural UI toggle still performs two writes: /v1/preferences for the toggle and a separate PATCH /v1/notifications/preferences carrying the same enabled value with the window. They land in one owner, but not in one transaction; a failed second write leaves the first one's change in place, and every reader then sees that same effective state.
  • The reminders route suite proves the single owner: after Telegram /quiet a reminder inside the window is suppressed, and after the PATCH turns quiet hours off it is delivered; the profile toggle reaches the dispatcher for a stored record and, through the seed, for a member who never saved preferences, without writing a record for them. The message-center route suite adds a seed-only member whose dispatch is delayed. The same reminders suite proves that after a simulated restart a first window-only PATCH keeps the profile's quiet hours on in the profile's timezone and suppresses the reminder, that a first Telegram /quiet takes the profile's timezone, and that a profile PATCH whose quiet-hours write fails, or whose profile save fails after it, leaves both durable stores with their previous values.
  • The twelve-case API suite proves same-process PATCH→GET round trips for the custom window and every domain × modality × kind record, including scope and validation gates. Its first direct PATCH asserts only that enabled is a boolean. The named browser/API suites are not restart tests.
  • The five-case browser suite proves the natural dual-write toggle, a narrowed weekday mask and changed start time after reload, global push gating, Nisaba/Metis lanes, and digest recommendation copy. Reload exercises the same BFF process.
  • Focused notification durability tests now prove write-before-publish rollback, ordered retry, restart restoration, exact-subject erasure, adjacent-subject preservation, and stale-write rejection for both custom preferences and read state. A gated real-Postgres suite repeats restart and erasure-fence proof.

The message-center proof is a policy seam, not bound-channel transport#

  • messages-center-bff.spec.ts has sixteen real-HTTP cases. Four are directly decisive here: a routine message inside the active window is delayed without an inbox row; explicit after-window replay writes the row and later receipt stages; an active crisis frame holds due replay; and a critical incident bypasses delay.
  • Quiet-hours delayed jobs share the required message-center snapshot with messages, receipts, suppressions, revisions, and deletion fences. Production startup hydrates it before traffic, and dispatch awaits persistence before returning 202; no timer claims due work, so an admin must still invoke POST /v1/admin/customer-messages/replay-due.
  • Replay commits a successful message, BFF-authored receipts, and delayed-row removal as one candidate. Snapshot failure retains the original job; policy rejection or a gate exception becomes a durable queued failure/hold. The focused eleven-case unit suite also proves restart recovery, write rollback, exact-subject erasure, adjacent-user preservation, and send/delete ordering; one database-gated case repeats restart and erasure-fence proof on Postgres.
  • This dispatch route does not read GET /v1/profile/channels and never invokes email, SMS, WhatsApp, push, or Telegram providers. Its channel value selects local policy and receipt labels only. Replay authors sent and delivered itself without receiving a provider message id or callback.

Real reminder transports exist, but the profile-bound handoff is incomplete#

  • The separate reminder cycle can call real SendGrid/SMTP, Twilio, Meta WhatsApp, FCM, APNs, Expo, or Web Push transports when matching credentials and recipient fields are present; missing credentials yield missing-config, never fabricated success. In-app reminder delivery is available independently, and since audit-remediation P4.a (commit aa02df671ce) each in-app copy appears in /v1/notifications as kind reminder for its recipient only, with read and dismissed state in the notification read-state store.
  • BFF startup resolves verified email/SMS/WhatsApp binding fields into the MessageRecipient of four automatic producers: streak, due-assignment, upcoming-session and content-drop reminders. The Nyx event producer receives neither the bindings nor a push binding, so its reminders carry an empty external recipient and reach the in-app inbox only. Since audit-remediation P2.c a reminder goes out on its external channel only with the member's consent (a granted notifications_push, notifications_email or notifications_sms consent, or the Telegram chat request that set it) and, for email/SMS/ WhatsApp, a verified binding. Without both it reaches the in-app inbox only, and the cycle reports it under externalSuppressed, apart from delivery failures. Since audit-remediation P2.b the member's toggles, read at send time, narrow that further: master push off, or the reminder domain's push off, keeps a push reminder to its in-app copy; the domain's reminder kind off suppresses the reminder entirely; the domain's in-app off drops only its inbox copy. Only a reminder that names its domain is held to that domain's toggles (streak: arete, Nyx: nyx, due assignment: metis; session, content-drop and admin callers may name one); any other is held to the master push switch alone. That is meaningful source wiring, but it does not complete this journey.
  • Reminder schedules, delivered-id ownership, the in-app inbox, and deleted-recipient fences now share a database-backed snapshot. Production requires the sink; schedule, cycle, and erasure mutations serialize, commit the candidate snapshot before publishing it in memory, and return explicit persistence or deleted-subject failures instead of acknowledging drift.
  • Focused durability tests cover failed commits, retry, exact-subject deletion, adjacent-subject preservation, in-flight create/delete ordering, legacy-owner repair, restart hydration, and a gated real-Postgres restart/erasure path. The optional worker now acquires a cycle lease before producing or delivering: shared Redis fences worker ticks across replicas, while a single-process deployment uses an explicit local lease. Lease failure skips the tick without consuming scheduled work. The lease covers worker ticks only: the operator's POST /v1/reminders/run-cycle and schedule or erasure writes do not take it, it expires without renewal, and the snapshot commit is an unconditional save that does not check it.
  • The streak, Nyx, due-assignment, upcoming-session, and content-drop automatic producers all set channel: 'push'. The delivery router therefore consults a push token and ignores the copied email, phone, and WhatsApp recipient fields. Enabling the optional worker does not by itself send to those bound addresses, and without the member's push consent those reminders reach the in-app inbox only.
  • The admin schedule route can submit an email/SMS/WhatsApp reminder, but its payload supplies the recipient separately, and any opt-in it carries is dropped at intake. Awaited snapshot persistence makes the schedule durable; the policy check still verifies only that some binding exists for the channel, not that the supplied address equals the verified address. No named suite demonstrates or closes this join.

Telegram is a different identity system#

  • The five-case Telegram binding suite signs a genuine Login Widget payload, proves the exact non-sensitive scopes, rejects tampered and missing hashes, and classifies six sensitive actions as requiring primary-credential challenge. The Login Widget now awaits a durable Telegram user-state binding; the authenticated link-token flow, webhook completion, /unlink, captures, voice preference, and delivery suppression use the same ordered snapshot.
  • Production startup requires that snapshot and hydrates it before traffic. The six-case focused suite proves candidate-before-publish capture and link writes, failed-write rollback, restart restoration, independent profile and saved-content fences, adjacent-subject preservation, both write/delete race orders, failed-erasure rollback, and fail-closed missing-sink behavior. Its one-case real-Postgres companion repeats restart, export, and both erasure fences, but collected as skipped here without a database URL.
  • The profile export includes secret-safe link, voice, and suppression state; raw link nonces are hashed. The saved-content export includes Telegram captures. Account deletion composes the profile and capture erasers as two independent signed-service categories.
  • The public Login Widget route derives oshunUserId as iris:<telegram-user-id>; it does not authenticate a current profile member or create an email/SMS/WhatsApp row. The authenticated deep-link account flow can bind a profile subject, but the five browser cases do not prove that convergence or a profile-inventory projection. Bot reply delivery remains a distinct provider path.
  • telegram-webhook-delivery.spec.ts contains 24 cases, but only its final two Mini App cases directly support this binding result, and both are negative HMAC branches. The other 22 belong to the Telegram assistant-delivery journey and must not inflate this page's ownership proof.

Boundaries and gaps#

  • A provider-accepted send is not a delivered verification code. sent means the provider API accepted the request within 8 s; no callback or inbox receipt confirms arrival, and the delivery spec doubles the transport. A production bind without email or SMS credentials, and every production WhatsApp bind, still returns missing-config.
  • A preview code is not production verification. It exists only outside production and only when no provider is configured, so development and browser automation can finish the round trip.
  • A verified address is not provider consent. The profile flow records address ownership, not tenant permission, A2P/WhatsApp opt-in, capability, residency, suppression, or provider receipt.
  • Recipient resolution is not bound-address delivery. Automatic producers choose push, and manual schedules supply their own recipient object.
  • A durable reminder snapshot is not a bound-recipient join. It preserves exactly the recipient object the producer or admin supplied; it does not prove equality with the profile binding.
  • A cycle lease is not a bound-recipient join. It fences worker ticks against each other while its unrenewed lease lasts, not an operator-triggered cycle or a schedule or erasure write, and it does not prove that a supplied delivery address matches the profile's verified binding.
  • Two durable snapshots are not one atomic quiet-hours commit. The profile route writes the toggle to the owner before saving the consumer profile's mirror, and puts the stored value back if that save fails; that is a compensating write, not a transaction, so an outage that also refuses the put-back leaves the owner changed until the member retries the same request. The editor still sends the toggle and window as two requests. Every reader reads the one owner.
  • A named browser reload is not the retained restart proof. The source-level notification, binding, and Telegram durability suites cover restart and erasure, while the seven named Playwright specs keep one BFF process and do not retain a backing-tier restart trace.
  • A durable delayed entry is not an automatic replay scheduler. The job and its failure state survive restart, but they move only after an explicit admin call; there is no timer, distributed claim, or leader lease.
  • A database-backed snapshot is not multi-writer arbitration. Ordered candidate-before-publish mutation protects one process and acknowledged restart state, but does not itself prove concurrent BFF writers cannot replace one another's snapshot.
  • A replay-authored receipt is not provider acknowledgment. The same BFF writes the queued, sent, and delivered stages without a provider callback.
  • A static phrase is not account step-up. channel-revoke is shipped in the client and compared literally by the server.
  • An unbound row is not a revocation cascade. Account-level data deletion can erase and fence durable profile bindings, device sessions/tokens, notification preferences/read state, reminder continuity, and exact-subject message-center history/suppressions/delayed work, plus the exact-subject Telegram profile and capture partitions. The single profile-channel DELETE does not invoke those other erasers; independently supplied recipients, provider subscriptions, other bindings, device tokens, Telegram state, Mini App sessions, and chat caches are not cancelled by unbinding.
  • A Telegram-derived Iris subject is not a profile channel binding. It is a separate HMAC-backed identity seam with durable link and unlink paths. Exact-subject export and erasure do not make iris:<telegram-id> the same subject as an independently authenticated profile member.
  • Broad suite membership is not direct proof. Only two of 24 Telegram webhook cases concern the Mini App HMAC boundary on this page.
  • Deep control coverage is not a complete delivery journey. Provider receipt of binding codes, production WhatsApp code delivery, atomic toggle/window updates, safe scheduler ownership, profile-bound provider delivery, callbacks, consent, and revocation remain outside the grade.
  • Source reconciliation is not execution. The focused message-center and channel-binding unit suites were rerun at 11 passed and 21 passed; the Telegram durability suite passed 6 cases. Their database-gated companions each collected as 1 skipped without a URL. None of the seven cited Playwright application specs was rerun for this documentation audit. The 2026-09-25 re-reconciliation reran the channel-binding delivery spec at 9 passed; the 2026-09-27 correction reran it, ten cases by then, at 10 passed.

Re-run evidence#

Run the seven focused specs sequentially against one immutable commit and one controlled BFF/web environment:

bash
pnpm --dir apps/oshun/web exec playwright test -c playwright.config.ts e2e/profile-notifications-index.spec.ts --project=chromium --workers=1
pnpm --dir apps/oshun/web exec playwright test -c playwright.config.ts e2e/profile-notification-preferences.spec.ts --project=chromium --workers=1
pnpm --dir apps/oshun/web exec playwright test -c playwright.config.ts e2e/notifications-preferences-api.spec.ts --project=chromium --workers=1
pnpm --dir apps/oshun/web exec playwright test -c playwright.config.ts e2e/profile-channel-bindings.spec.ts --project=chromium --workers=1
pnpm --dir apps/oshun/web exec playwright test -c playwright.config.ts e2e/telegram-binding-bff.spec.ts --project=chromium --workers=1
pnpm --dir apps/oshun/web exec playwright test -c playwright.config.ts e2e/telegram-webhook-delivery.spec.ts --project=chromium --workers=1
pnpm --dir apps/oshun/web exec playwright test -c playwright.config.ts e2e/messages-center-bff.spec.ts --project=chromium --workers=1
pnpm --dir apps/oshun/bff exec vitest run src/customer/customer-message-center-store-durability.spec.ts
OSHUN_ADMIN_DATABASE_URL=postgres://… pnpm --dir apps/oshun/bff exec vitest run -c vitest.integration.config.ts src/customer/customer-message-center-durability.integration.spec.ts
pnpm --dir apps/oshun/bff exec vitest run src/messaging-channels/channel-bindings-store.test.ts
pnpm --dir apps/oshun/bff exec vitest run src/routes/channel-bindings-delivery.spec.ts
OSHUN_ADMIN_DATABASE_URL=postgres://… pnpm --dir apps/oshun/bff exec vitest run -c vitest.integration.config.ts src/messaging-channels/channel-bindings-durability.integration.spec.ts
pnpm --dir apps/oshun/bff exec vitest run src/telegram/user-state-durability.spec.ts
OSHUN_ADMIN_DATABASE_URL=postgres://… pnpm --dir apps/oshun/bff exec vitest run -c vitest.integration.config.ts src/telegram/user-state-durability.integration.spec.ts

Retain the commit, environment mode, storage tier, generated customer and admin subjects, browser/BFF reports, binding and reminder snapshots, preference snapshots before and after process restart, erasure-fence read-back, and delayed message-center job/export state. Record both Postgres-gate outcomes and profile/ saved-content/session export and erasure read-back, including both Telegram partitions. A production-grade follow-up must also retain verification-code provider message ids and delivery callbacks, bound-address equality proof, automatic-worker claim/retry evidence, provider request/callback ids, consent and suppression read-back, genuine account step-up, and complete revocation audit evidence.

Source trail#

Cross-references#

Open questions#

  • Which provider callback or receipt will confirm that a sent binding code arrived, and which reviewed WhatsApp sender will the server construct for production binds (task 14.2)?
  • Which transaction or coordinator will make the editor's quiet-hours toggle and window, which share one owner since audit-remediation P2.a, one atomic customer intent across two routes?
  • Which scheduler will durably claim delayed messages, re-evaluate crisis and preference policy, retry idempotently, and acknowledge only after a durable transition?
  • The Redis lease fences worker ticks against each other. Which fencing token or conditional snapshot commit will also stop a holder that outlived its unrenewed lease, an operator-triggered cycle, or a schedule or erasure write on another replica from overwriting a cycle's snapshot?
  • Should automatic reminder producers select a verified email/SMS/WhatsApp binding when push is unavailable, and how will tenant allowlists, explicit opt-ins, cost, residency, and fallback order govern that choice?
  • How will manual schedules prove their recipient equals the verified binding rather than accepting an unrelated address for the same channel?
  • Which primary-credential challenge will replace the public revoke phrase, and which services must participate in a verifiable revocation cascade?
  • Should Telegram Login Widget identity, authenticated account deep-linking, Mini App sessions, bot suppression, and profile channel inventory converge on one explicit account-binding model or remain separate products?
  • Which retained provider and restart run will promote this result from deep control-plane coverage to an end-to-end delivery grade?