@almadar/std 16.217.0 → 16.219.0

package/behaviors/lolo/infra/atoms/std-data-import.lolo

@@ -1,5 +1,5 @@
 app std-data-import "1.0.0"
-"std-data-import — staged CSV import run, source-agnostic: upload → staged review → confirm → handoff. UPLOAD_CSV opens a run and persists an ImportBatch row (status uploaded, fieldMappingJson recorded verbatim for provenance); the host's file UI parses the CSV and answers with STAGE_ROWS, one JSON string per raw row, which the atom bulk-persists into import_rows against the batch id and presents as a staged review (row/error counts + Confirm/Discard). CONFIRM_IMPORT marks the batch confirmed and emits IMPORT_CONFIRMED { batchId, sourceName, rowCount } — the mapping+persist half is the CONSUMER organism's: it listens for IMPORT_CONFIRMED, fetches import_rows where batchId matches, maps each rowJson through its own field mapping, and persists into its own target entity (cross-atom persist into a consumer's entity is not expressible from here). This is deliberately the CSV-file path: the atom never calls a source service — sourceName/fieldMappingJson/targetEntity/historyWindowDays are declarative consumer configs, and any persist failure marks the batch row failed and fires IMPORT_FAILED, never a silent swallow. Compose with std-import for the file-picker menu."
+"std-data-import — staged CSV import run, source-agnostic: upload → staged review → confirm → parse+map → handoff. UPLOAD_CSV opens a run and persists an ImportBatch row (status uploaded, fieldMappingJson recorded verbatim for provenance); the host's file UI parses the CSV and answers with STAGE_ROWS, one JSON string per raw row, which the atom bulk-persists into import_rows against the batch id and presents as a staged review (row/error counts + Confirm/Discard). CONFIRM_IMPORT marks the batch confirmed, emits IMPORT_CONFIRMED { batchId, sourceName, rowCount }, and fetches the batch's staged rows; on fetch success the atom parses each rowJson via json/parse, remaps keys through the batch's mappingJson, and emits IMPORT_ROWS_PARSED { batchId, rows, failed } — the persist half is the CONSUMER organism's: it listens for IMPORT_ROWS_PARSED and persists the mapped rows into its own target entity (cross-atom persist into a consumer's entity is not expressible from here). This is deliberately the CSV-file path: the atom never calls a source service — sourceName/fieldMappingJson/targetEntity/historyWindowDays are declarative consumer configs, and any persist failure marks the batch row failed and fires IMPORT_FAILED, never a silent swallow. Compose with std-import for the file-picker menu."
 orbital DataImportOrbital {
 
   entity ImportBatch [persistent: import_batches] {
@@ -8,7 +8,7 @@ orbital DataImportOrbital {
     status : "uploaded" | "staged" | "confirmed" | "failed" @description "Lifecycle position of the import run." = uploaded
     rowCount : number @description "Number of rows staged for review." @synonyms "rows, staged count, record count" = 0
     errorCount : number @description "Number of rows the host parser flagged with errors during staging." @synonyms "errors, failed rows, parse errors" = 0
-    mappingJson : string @description "Source-column → target-field mapping (JSON string), recorded verbatim from config for provenance; the consumer's mapping layer applies it." @synonyms "field mapping, column mapping, mapping" = "{}"
+    mappingJson : string @description "Source-column → target-field mapping (JSON string), recorded verbatim from config for provenance; the atom applies it when parsing staged rows on confirm." @synonyms "field mapping, column mapping, mapping" = "{}"
     createdAt : number @description "Run start timestamp." = 0
   }
 
@@ -145,6 +145,9 @@ orbital DataImportOrbital {
           variant: success
         })
         (emit IMPORT_CONFIRMED { batchId: @entity.id, rowCount: @entity.rowCount, sourceName: @entity.sourceName })
+        (fetch ImportRow {
+          emit: { failure: IMPORT_PERSIST_FAILED, success: IMPORT_ROWS_FETCHED }
+        })
       ;; Same transient-failure self-loop as in `uploaded`.
       IMPORT_PERSIST_FAILED -> staged
         (set @entity.status failed)
@@ -166,6 +169,40 @@ orbital DataImportOrbital {
     }
 
     state confirmed {
+      ;; The parse half: fetch success delivers every staged row flat (?data);
+      ;; filter to this batch, keep rows whose rowJson parses to an object,
+      ;; remap keys through the batch's mappingJson, and hand the consumer
+      ;; mapped rows + a failed count (failed rows surface, never drop
+      ;; silently). json/parse yields null on invalid JSON, so the guard-level
+      ;; branch is validate/object on the parse result.
+      IMPORT_ROWS_FETCHED -> confirmed
+        (emit IMPORT_ROWS_PARSED {
+          batchId: @entity.id
+          failed: (array/len (array/filter ?data (fn row (and
+            ["=", (object/get @row "batchId"), @entity.id]
+            (not (validate/object (json/parse (object/get @row "rowJson"))))))))
+          rows: (array/map
+            (array/filter ?data (fn row (and
+              ["=", (object/get @row "batchId"), @entity.id]
+              (validate/object (json/parse (object/get @row "rowJson"))))))
+            (fn row (object/mapKeys
+              (json/parse (object/get @row "rowJson"))
+              (fn k (if (object/has (json/parse @entity.mappingJson) @k)
+                (object/get (json/parse @entity.mappingJson) @k)
+                @k)))))
+        })
+      ;; Same transient-failure self-loop as in `staged` — the row fetch can
+      ;; fail after the batch row was already persisted as confirmed.
+      IMPORT_PERSIST_FAILED -> confirmed
+        (set @entity.status failed)
+        (set @entity.errorCount 1)
+        (persist update ImportBatch { errorCount: 1, id: @entity.id, status: failed })
+        (emit IMPORT_FAILED { batchId: @entity.id, error: ?error })
+        (render-ui main {
+          message: ?error
+          type: alert
+          variant: error
+        })
       RESET -> idle
         (set @entity.status uploaded)
         (set @entity.rowCount 0)
@@ -174,6 +211,7 @@ orbital DataImportOrbital {
       ;; Self-loop so the validator sees an in-atom listener for the
       ;; externally-consumed confirmation event.
       IMPORT_CONFIRMED -> confirmed
+      IMPORT_ROWS_PARSED -> confirmed
     }
 
     state failed {
@@ -206,9 +244,22 @@ orbital DataImportOrbital {
         sourceName : string
         rowCount : number
       }
-        @description "The user confirmed the staged review and the batch row is persisted as confirmed. Consumers listen, fetch import_rows where batchId matches, map each rowJson through their field mapping, and persist into their own target entity."
+        @description "The user confirmed the staged review and the batch row is persisted as confirmed. The atom then fetches the batch's staged rows, parses and key-maps them, and emits IMPORT_ROWS_PARSED for the consumer's persist half."
         @synonyms "import confirmed, commit import, accept staged rows, approve import"
         @tier "domain"
+      IMPORT_ROWS_FETCHED {
+        data : [ImportRow]
+      }
+        @description "import_rows collection-fetch success on confirm — payload carries every staged row flat; the atom filters to @entity.id by batchId in the IMPORT_ROWS_PARSED arm (self-loop only)"
+        @tier "secondary"
+      IMPORT_ROWS_PARSED -> external {
+        batchId : string!
+        failed : number
+        rows : [Map string scalar]
+      }
+        @description "Confirmed rows parsed and key-mapped: each staged row's rowJson was parsed via json/parse and remapped through the batch's mappingJson; failed counts rows whose rowJson did not parse to an object (surfaced, never dropped). The consumer persists rows into its own target entity and marks them imported."
+        @synonyms "rows parsed, rows mapped, import rows ready"
+        @tier "domain"
       IMPORT_FAILED -> external {
         batchId : string
         error : string!
@@ -233,7 +284,7 @@ orbital DataImportOrbital {
         @description "Host-side CSV parsing finished: rows carries one JSON string per parsed row (raw source shape, pre-mapping); errorCount counts rows the parser flagged. The atom bulk-persists them into import_rows and opens the staged review."
         @tier "internal"
       CONFIRM_IMPORT
-        @description "The user approved the staged review; the batch is marked confirmed and IMPORT_CONFIRMED fires for the consumer's mapping+persist half."
+        @description "The user approved the staged review; the batch is marked confirmed, IMPORT_CONFIRMED fires, and the atom parses+maps the staged rows into IMPORT_ROWS_PARSED for the consumer's persist half."
         @synonyms "confirm import, approve staged rows, accept import"
         @tier "domain"
       DISCARD_IMPORT
@@ -252,7 +303,7 @@ orbital DataImportOrbital {
         @tier "domain"
       fieldMappingJson : string = "{}"
         @label "Field mapping (JSON)"
-        @description "JSON object mapping source CSV column names to target field names. Stored verbatim on the batch row (mappingJson) so the consumer's mapping layer applies the same mapping when it persists staged rows into the target entity."
+        @description "JSON object mapping source CSV column names to target field names. Stored verbatim on the batch row (mappingJson); the atom applies it when it parses staged rows into IMPORT_ROWS_PARSED, so the consumer persists already-mapped rows into the target entity."
         @synonyms "field mapping, column mapping, map columns, remap fields, csv columns"
         @tier "domain"
       targetEntity : string = ""

package/behaviors/lolo/infra/atoms/std-notification-center.lolo

@@ -9,12 +9,13 @@ orbital NotificationCenterOrbital {
 
   entity NotificationPreference [persistent: notificationPreferences] {
     id : string!
-    userId : string @description "Owner of this preference row — rows are meant to be private to their owner. Access predicates need an [identity] roster, so the binding organism (which declares one) owns the @read/@update scoping; the generic atom cannot." @synonyms "user, owner, account" = ""
-    eventType : string @description "Event key this preference applies to (matches a listener's eventKey); blank = all events." @synonyms "event, trigger, subscription, topic" = ""
+    personId : string! @description "Owner of this preference row — rows are meant to be private to their owner. Access predicates need an [identity] roster, so the binding organism (which declares one) owns the @read/@update scoping; the generic atom cannot." @synonyms "user, owner, account"
+    eventKey : string @description "Event key this preference applies to (matches a listener's eventKey); blank = all events." @synonyms "event, trigger, subscription, topic" = ""
+    channel : "in_app" | "email" | "push" | "slack" | "sms" | "webhook" @description "Channel override for this user." @synonyms "preferred channel, delivery method" = in_app
     mode : "instant" | "digest" | "off" @description "Delivery mode: instant (default), digest (deferred to the drain cycle), or off (muted)." @synonyms "delivery mode, frequency, cadence, mute, defer" = instant
-    channel : string @description "Channel override for this user (in-app/email/sms/push/webhook); blank = the listener's configured channel." @synonyms "preferred channel, delivery method" = ""
-    quietStartHour : number @description "Per-user quiet-hours start (hour 0-23); equal to quietEndHour = disabled." @synonyms "quiet start, do not disturb from" = 0
-    quietEndHour : number @description "Per-user quiet-hours end (hour 0-23); equal to quietStartHour = disabled." @synonyms "quiet end, do not disturb until" = 0
+    quietHours : string @description "Per-user quiet-hours window as \"HH:MM-HH:MM\" (e.g. 22:00-07:00); blank = disabled." @synonyms "do not disturb, quiet window, night mode" = ""
+    createdAt : number @description "Timestamp indicating when this preference row was created." @synonyms "creation time, created" = 0
+    updatedAt : number @description "Timestamp indicating when this preference row was last updated." @synonyms "modified, last updated" = 0
   }
 
   entity PushSubscription [persistent: pushSubscriptions] {
@@ -126,20 +127,21 @@ orbital NotificationCenterOrbital {
       SAVE_PREFERENCE -> idle
         (persist create NotificationPreference {
           channel: ?channel
-          eventType: ?eventType
+          createdAt: @now
+          eventKey: ?eventKey
           mode: ?mode
-          quietEndHour: ?quietEndHour
-          quietStartHour: ?quietStartHour
-          userId: @user.id
+          personId: @user.id
+          quietHours: ?quietHours
+          updatedAt: @now
         } { emit: { failure: PREFERENCE_SAVE_FAILED, success: PREFERENCE_SAVED } })
       UPDATE_PREFERENCE -> idle
         (persist update NotificationPreference {
           id: ?id
           channel: ?channel
-          eventType: ?eventType
+          eventKey: ?eventKey
           mode: ?mode
-          quietEndHour: ?quietEndHour
-          quietStartHour: ?quietStartHour
+          quietHours: ?quietHours
+          updatedAt: @now
         } { emit: { failure: PREFERENCE_SAVE_FAILED, success: PREFERENCE_SAVED } })
       DELETE_PREFERENCE -> idle
         (persist delete NotificationPreference ?id { emit: { failure: PREFERENCE_SAVE_FAILED, success: PREFERENCE_DELETED } })
@@ -171,19 +173,17 @@ orbital NotificationCenterOrbital {
 
     listens {
       SAVE_PREFERENCE {
-        eventType : string
+        eventKey : string
         mode : string
         channel : string
-        quietStartHour : number
-        quietEndHour : number
+        quietHours : string
       }
       UPDATE_PREFERENCE {
         id : string
-        eventType : string
+        eventKey : string
         mode : string
         channel : string
-        quietStartHour : number
-        quietEndHour : number
+        quietHours : string
       }
       DELETE_PREFERENCE {
         id : string

package/behaviors/lolo/infra/atoms/std-notification-preferences.lolo

@@ -1,5 +1,5 @@
 app std-notification-preferences "1.0.0"
-"std-notification-preferences — per-person notification preference store plus a consultable gate. Owns NotificationPreference rows (one per person + event key: channel override in_app/email/push/slack, mode instant/digest, quiet-hours window 'HH:MM-HH:MM' such as 22:00-07:00). The PreferencesManage trait is standard CRUD over the store (list / create / update / delete, persisted, success/failure cascade arms): a data-grid browse plus ModalRecordModal create/edit forms whose SAVE carries the full row payload (std-list daisy-chain idiom). The PreferenceGate trait is the consult half other notify traits call: emit CHECK_PREFERENCE { personId, eventKey } and the gate fetches the matching row (a row whose eventKey is blank applies to every event) and answers PREFERENCE_RESOLVED { personId, eventKey, channel, mode, suppressed } — suppressed is true only when the row's quietHours window covers the current hour; mode 'digest' rides on the verdict for the caller to defer. Default policy: no matching row — or a failed lookup — resolves fail-open to { channel: in_app, mode: instant, suppressed: false }; the absence of a preference never silences a notification."
+"std-notification-preferences — per-person notification preference store plus a consultable gate. Owns NotificationPreference rows (one per person + event key: channel override in_app/email/push/slack/sms/webhook, mode instant/digest/off, quiet-hours window 'HH:MM-HH:MM' such as 22:00-07:00). The PreferencesManage trait is standard CRUD over the store (list / create / update / delete, persisted, success/failure cascade arms): a data-grid browse plus ModalRecordModal create/edit forms whose SAVE carries the full row payload (std-list daisy-chain idiom). The PreferenceGate trait is the consult half other notify traits call: emit CHECK_PREFERENCE { personId, eventKey } and the gate fetches the matching row (a row whose eventKey is blank applies to every event) and answers PREFERENCE_RESOLVED { personId, eventKey, channel, mode, suppressed } — suppressed is true only when the row's quietHours window covers the current hour; mode 'digest' rides on the verdict for the caller to defer. Default policy: no matching row — or a failed lookup — resolves fail-open to { channel: in_app, mode: instant, suppressed: false }; the absence of a preference never silences a notification."
 orbital NotificationPreferencesOrbital {
     uses Modal from "std/behaviors/std-modal"
 
@@ -7,12 +7,12 @@ orbital NotificationPreferencesOrbital {
 
     type PREFERENCE_RESOLVED = Event { personId : string, eventKey : string, channel : string, mode : string, suppressed : boolean } "The gate's verdict. Fail-open defaults: no matching row or a failed lookup resolves { channel: in_app, mode: instant, suppressed: false } — absence of a preference never silences a notification."
 
-  entity NotificationPreference [persistent: notification_preferences] {
+  entity NotificationPreference [persistent: notificationPreferences] {
     id : string!
     personId : string! @description "The person this preference row belongs to." @synonyms "user, recipient, owner, account"
-    eventKey : string! @description "Event key this preference applies to (matches a notify listener's eventKey); blank = all events." @synonyms "event, trigger, topic, subscription"
-    channel : "in_app" | "email" | "push" | "slack" @description "Delivery channel override for this person." @synonyms "preferred channel, delivery method" = in_app
-    mode : "instant" | "digest" @description "Delivery mode: instant (default) or digest (deferred to a batch cycle)." @synonyms "delivery mode, frequency, cadence, defer" = instant
+    eventKey : string @description "Event key this preference applies to (matches a notify listener's eventKey); blank = all events." @synonyms "event, trigger, topic, subscription" = ""
+    channel : "in_app" | "email" | "push" | "slack" | "sms" | "webhook" @description "Delivery channel override for this person." @synonyms "preferred channel, delivery method" = in_app
+    mode : "instant" | "digest" | "off" @description "Delivery mode: instant (default), digest (deferred to a batch cycle), or off (muted)." @synonyms "delivery mode, frequency, cadence, mute, defer" = instant
     quietHours : string @description "Quiet-hours window as \"HH:MM-HH:MM\" (e.g. 22:00-07:00); blank or equal start/end = disabled." @synonyms "do not disturb, quiet window, night mode" = ""
     createdAt : number @description "Timestamp indicating when this preference row was created." @synonyms "creation time, created" = 0
     updatedAt : number @description "Timestamp indicating when this preference row was last updated." @synonyms "modified, last updated" = 0

package/behaviors/lolo/infra/atoms/std-notify-on-event.lolo

@@ -1,6 +1,6 @@
 app std-notify-on-event "2.0.0"
-"std-notify-on-event — cross-orbital wiring atom. Subscribes to events from another orbital (e.g. CheckoutOrbital emits OrderPlaced, OrderRecordOrbital reacts via this atom) and dispatches a notification. Use when one orbital needs to react to or be notified about events that happen in another orbital — the wiring goes through this atom's `EventOccurred` listener which the molecule renames via traitOverrides.events to the upstream event name. Dispatch gates on `guardOp`: `eq` (default) does string-equality on `triggerStatus` against the upstream event's `status` field; `gt`/`lt`/`gte`/`lte` instead numerically compare `guardField` (read from the event's `data` payload) against `guardValue`, for threshold-crossing asks such as low-stock alerts. Resolves recipient from `recipients` (first entry; multi-recipient fan-out is a future extension), falling back to `fallbackRecipient` when set, or `@user.id` otherwise. Skips dispatch when the recipient is in `suppressionList`. Delivery consults std-notification-center data before dispatching: per-user NotificationPreference rows (matched on `userId` = recipient and `eventType` = this listener's `eventKey`, blank = all) can mute (`mode: off`), defer to the digest drain (`mode: digest`), override the channel, or impose per-user quiet hours; the atom-level `quietStartHour`/`quietEndHour` window and the `frequencyCapPerWeek` rolling cap (counted against dispatched NotificationRecord audit rows for the same recipient + channel) suppress likewise. Every suppression persists an honest audit row (`dispatched: false` with the reason in `error`: quiet-hours / digest-deferred / muted-by-preference / frequency-cap / no-push-subscription) which std-notification-center's digest cycle drains later. Channels: `in-app` emits the `notify` toast; `email`/`sms`/`webhook` dispatch through call-service (email.send / twilio.sendSMS / webhook.send); `push` looks up the recipient's PushSubscription row (owned by std-notification-center) and dispatches web-push via push.send (`pushTitle` falls back to `template`; `pushDeepLink`/`pushIcon` optional). The audit row's `dispatched` flag is honest — true only once the service call succeeds."
-type PrefRow = { userId : string, eventType : string, mode : string, channel : string, quietStartHour : number, quietEndHour : number }
+"std-notify-on-event — cross-orbital wiring atom. Subscribes to events from another orbital (e.g. CheckoutOrbital emits OrderPlaced, OrderRecordOrbital reacts via this atom) and dispatches a notification. Use when one orbital needs to react to or be notified about events that happen in another orbital — the wiring goes through this atom's `EventOccurred` listener which the molecule renames via traitOverrides.events to the upstream event name. Dispatch gates on `guardOp`: `eq` (default) does string-equality on `triggerStatus` against the upstream event's `status` field; `gt`/`lt`/`gte`/`lte` instead numerically compare `guardField` (read from the event's `data` payload) against `guardValue`, for threshold-crossing asks such as low-stock alerts. Resolves recipient from `recipients` (first entry; multi-recipient fan-out is a future extension), falling back to `fallbackRecipient` when set, or `@user.id` otherwise. Skips dispatch when the recipient is in `suppressionList`. Delivery consults std-notification-center data before dispatching: per-person NotificationPreference rows (matched on `personId` = recipient and `eventKey` = this listener's `eventKey`, blank = all) can mute (`mode: off`), defer to the digest drain (`mode: digest`), override the channel, or impose per-user quiet hours (a 'HH:MM-HH:MM' window, blank = none); the atom-level `quietStartHour`/`quietEndHour` window and the `frequencyCapPerWeek` rolling cap (counted against dispatched NotificationRecord audit rows for the same recipient + channel) suppress likewise. Every suppression persists an honest audit row (`dispatched: false` with the reason in `error`: quiet-hours / digest-deferred / muted-by-preference / frequency-cap / no-push-subscription) which std-notification-center's digest cycle drains later. Channels: `in-app` emits the `notify` toast; `email`/`sms`/`webhook` dispatch through call-service (email.send / twilio.sendSMS / webhook.send); `push` looks up the recipient's PushSubscription row (owned by std-notification-center) and dispatches web-push via push.send (`pushTitle` falls back to `template`; `pushDeepLink`/`pushIcon` optional). The audit row's `dispatched` flag is honest — true only once the service call succeeds."
+type PrefRow = { personId : string, eventKey : string, mode : string, channel : string, quietHours : string }
 type AuditRow = { recipient : string, channel : string, dispatched : boolean, recordedAt : number }
 type SubRow = { userId : string, endpoint : string, p256dh : string, auth : string }
 orbital NotifyOnEventOrbital {
@@ -19,8 +19,7 @@ orbital NotifyOnEventOrbital {
     recordedAt : number @description "Timestamp indicating when the notification record was created." @synonyms "creation time, timestamp, date, when" = 0
     prefMode : string @description "Scratch: effective preference mode resolved for the current dispatch (instant/digest/off)." @synonyms "resolved mode" = ""
     prefChannel : string @description "Scratch: channel override from the matched preference row; blank = no override." @synonyms "channel override" = ""
-    prefQuietStart : number @description "Scratch: per-user quiet-hours start (hour 0-23) from the matched preference row." @synonyms "user quiet start" = 0
-    prefQuietEnd : number @description "Scratch: per-user quiet-hours end (hour 0-23) from the matched preference row." @synonyms "user quiet end" = 0
+    prefQuietHours : string @description "Scratch: per-user quiet-hours window \"HH:MM-HH:MM\" from the matched preference row; blank = none." @synonyms "user quiet hours" = ""
     pushEndpoint : string @description "Scratch: push endpoint of the recipient's subscription for the current dispatch." @synonyms "subscription endpoint" = ""
     pushP256dh : string @description "Scratch: p256dh key of the recipient's push subscription." @synonyms "push key" = ""
     pushAuth : string @description "Scratch: auth secret of the recipient's push subscription." @synonyms "push auth" = ""
@@ -28,12 +27,13 @@ orbital NotifyOnEventOrbital {
 
   entity NotificationPreference [persistent: notificationPreferences] {
     id : string!
-    userId : string @description "Owner of this preference row." @synonyms "user, owner, account" = ""
-    eventType : string @description "Event key this preference applies to (matches the listener's eventKey); blank = all events." @synonyms "event, trigger, subscription" = ""
-    mode : string @description "Delivery mode: instant, digest, or off." @synonyms "delivery mode, frequency, cadence" = instant
-    channel : string @description "Channel override for this user (in-app/email/sms/push/webhook); blank = the listener's configured channel." @synonyms "preferred channel, delivery method" = ""
-    quietStartHour : number @description "Per-user quiet-hours start (hour 0-23); equal to quietEndHour = disabled." @synonyms "quiet start, do not disturb from" = 0
-    quietEndHour : number @description "Per-user quiet-hours end (hour 0-23); equal to quietStartHour = disabled." @synonyms "quiet end, do not disturb until" = 0
+    personId : string! @description "Owner of this preference row." @synonyms "user, owner, account"
+    eventKey : string @description "Event key this preference applies to (matches the listener's eventKey); blank = all events." @synonyms "event, trigger, subscription" = ""
+    channel : "in_app" | "email" | "push" | "slack" | "sms" | "webhook" @description "Channel override for this user." @synonyms "preferred channel, delivery method" = in_app
+    mode : "instant" | "digest" | "off" @description "Delivery mode: instant, digest, or off." @synonyms "delivery mode, frequency, cadence" = instant
+    quietHours : string @description "Per-user quiet-hours window as \"HH:MM-HH:MM\" (e.g. 22:00-07:00); blank = disabled." @synonyms "do not disturb, quiet window, night mode" = ""
+    createdAt : number @description "Timestamp indicating when this preference row was created." @synonyms "creation time, created" = 0
+    updatedAt : number @description "Timestamp indicating when this preference row was last updated." @synonyms "modified, last updated" = 0
   }
 
   entity PushSubscription [persistent: pushSubscriptions] {
@@ -72,10 +72,9 @@ orbital NotifyOnEventOrbital {
           severity: @entity.severity
         })
       NOTIFY_PREFS_LOADED -> idle
-        (set @entity.prefMode (if ["=", (array/len (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))), 0] "instant" (object/get (array/first (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))) mode)))
-        (set @entity.prefChannel (if ["=", (array/len (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))), 0] "" (object/get (array/first (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))) channel)))
-        (set @entity.prefQuietStart (if ["=", (array/len (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))), 0] 0 (object/get (array/first (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))) quietStartHour)))
-        (set @entity.prefQuietEnd (if ["=", (array/len (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))), 0] 0 (object/get (array/first (array/filter ?data (fn p (and ["=", (object/get @p userId), @entity.recipient] (or ["=", (object/get @p eventType), ""] ["=", (object/get @p eventType), @config.eventKey]))))) quietEndHour)))
+        (set @entity.prefMode (if ["=", (array/len (array/filter ?data (fn p (and ["=", (object/get @p personId), @entity.recipient] (or ["=", (object/get @p eventKey), ""] ["=", (object/get @p eventKey), @config.eventKey]))))), 0] "instant" (object/get (array/first (array/filter ?data (fn p (and ["=", (object/get @p personId), @entity.recipient] (or ["=", (object/get @p eventKey), ""] ["=", (object/get @p eventKey), @config.eventKey]))))) mode)))
+        (set @entity.prefChannel (if ["=", (array/len (array/filter ?data (fn p (and ["=", (object/get @p personId), @entity.recipient] (or ["=", (object/get @p eventKey), ""] ["=", (object/get @p eventKey), @config.eventKey]))))), 0] "" (object/get (array/first (array/filter ?data (fn p (and ["=", (object/get @p personId), @entity.recipient] (or ["=", (object/get @p eventKey), ""] ["=", (object/get @p eventKey), @config.eventKey]))))) channel)))
+        (set @entity.prefQuietHours (if ["=", (array/len (array/filter ?data (fn p (and ["=", (object/get @p personId), @entity.recipient] (or ["=", (object/get @p eventKey), ""] ["=", (object/get @p eventKey), @config.eventKey]))))), 0] "" (object/get (array/first (array/filter ?data (fn p (and ["=", (object/get @p personId), @entity.recipient] (or ["=", (object/get @p eventKey), ""] ["=", (object/get @p eventKey), @config.eventKey]))))) quietHours)))
         (set @entity.channel (if ["=", @entity.prefChannel, ""] @entity.channel @entity.prefChannel))
         (if ["=", @entity.prefMode, "off"] (persist create NotificationRecord {
           channel: @entity.channel
@@ -93,7 +92,7 @@ orbital NotifyOnEventOrbital {
           recipient: @entity.recipient
           recordedAt: @now
           severity: @entity.severity
-        }) (if (and (not ["=", @entity.prefQuietStart, @entity.prefQuietEnd]) (if ["<", @entity.prefQuietStart, @entity.prefQuietEnd] (and [">=", (time/hour @now), @entity.prefQuietStart] ["<", (time/hour @now), @entity.prefQuietEnd]) (or [">=", (time/hour @now), @entity.prefQuietStart] ["<", (time/hour @now), @entity.prefQuietEnd]))) (persist create NotificationRecord {
+        }) (if (and (str/includes @entity.prefQuietHours "-") ["!=", (str/slice (array/first (str/split @entity.prefQuietHours "-")) 0 2), (str/slice (array/nth (str/split @entity.prefQuietHours "-") 1) 0 2)] (if ["<", (str/slice (array/first (str/split @entity.prefQuietHours "-")) 0 2), (str/slice (array/nth (str/split @entity.prefQuietHours "-") 1) 0 2)] (and [">=", (time/hour @now), (str/slice (array/first (str/split @entity.prefQuietHours "-")) 0 2)] ["<", (time/hour @now), (str/slice (array/nth (str/split @entity.prefQuietHours "-") 1) 0 2)]) (or [">=", (time/hour @now), (str/slice (array/first (str/split @entity.prefQuietHours "-")) 0 2)] ["<", (time/hour @now), (str/slice (array/nth (str/split @entity.prefQuietHours "-") 1) 0 2)]))) (persist create NotificationRecord {
           channel: @entity.channel
           dispatched: false
           error: "quiet-hours"
@@ -101,7 +100,7 @@ orbital NotifyOnEventOrbital {
           recipient: @entity.recipient
           recordedAt: @now
           severity: @entity.severity
-        }) (if ["=", @entity.channel, in-app] (do (set @entity.dispatched true) (notify @config.severity @config.template)) (fetch NotificationRecord {
+        }) (if (or ["=", @entity.channel, in-app] ["=", @entity.channel, in_app]) (do (set @entity.dispatched true) (notify @config.severity @config.template)) (fetch NotificationRecord {
           emit: { failure: NOTIFY_LOOKUP_FAILED, success: NOTIFY_CAP_LOADED }
           filter: [">", (object/get @entity recordedAt), ["-", @now, 604800000]]
         })))))
@@ -380,12 +379,12 @@ orbital NotifyOnEventOrbital {
         @tier "internal"
       eventKey : string = ""
         @label "Event key for preferences"
-        @description "Stable key naming the upstream event this listener is bound to (e.g. 'OrderPlaced'). NotificationPreference rows (std-notification-center) whose eventType equals this key — or is blank — apply to this listener's dispatches."
+        @description "Stable key naming the upstream event this listener is bound to (e.g. 'OrderPlaced'). NotificationPreference rows (std-notification-center) whose eventKey equals this key — or is blank — apply to this listener's dispatches."
         @synonyms "preference key, event name, subscription key, notification topic"
         @tier "policy"
       notifyChannel : "in-app" | "email" | "sms" | "push" | "webhook" = in-app
         @label "Channel"
-        @description "Delivery channel. `in-app` (default) emits the in-app `notify` toast. `email`/`sms`/`webhook` dispatch through call-service at event time (email.send / twilio.sendSMS / webhook.send) and persist a NotificationRecord audit row with an honest `dispatched` flag: true only once the service call succeeds, false plus the failure detail in `error` otherwise. `push` looks up the recipient's PushSubscription row (captured by std-notification-center's subscribe flow) and dispatches web-push via push.send — a recipient with no subscription records the audit row undispatched (`no-push-subscription`). `webhook` requires `webhookUrl` to actually dispatch; a blank `webhookUrl` still records the audit row undispatched rather than failing. A per-user NotificationPreference row with a non-blank `channel` overrides this value for that recipient."
+        @description "Delivery channel. `in-app` (default) emits the in-app `notify` toast. `email`/`sms`/`webhook` dispatch through call-service at event time (email.send / twilio.sendSMS / webhook.send) and persist a NotificationRecord audit row with an honest `dispatched` flag: true only once the service call succeeds, false plus the failure detail in `error` otherwise. `push` looks up the recipient's PushSubscription row (captured by std-notification-center's subscribe flow) and dispatches web-push via push.send — a recipient with no subscription records the audit row undispatched (`no-push-subscription`). `webhook` requires `webhookUrl` to actually dispatch; a blank `webhookUrl` still records the audit row undispatched rather than failing. A per-user NotificationPreference row's `channel` overrides this value for that recipient."
         @synonyms "delivery method, notification channel, send via, dispatch through, push notification, web push"
         @tier "policy"
       emailSubject : string = ""

package/behaviors/lolo/ui/core/atoms/std-gantt-schedule.lolo

@@ -0,0 +1,215 @@
+app std-gantt-schedule "1.0.0"
+"std-gantt-schedule — GENERIC view-only Gantt/timeline atom: fetches a task collection on INIT and renders it as bars on a day-scale axis via the gantt pattern, with group headers, dependency arrows, and a today marker. Fully rebindable: a host overrides the linked entity and points the field-mapping configs (labelField/startField/endField/durationField/statusField/groupField) at its own columns; clicking a bar emits the config-named onBarClick event with the row id. No drag-edit, no zoom — schedule viewing only."
+type GanttLinkSpec = { from : string!, to : string! }
+orbital GanttScheduleOrbital {
+    type TaskLoaded = Event { data : [Task] } "Fired when Task finishes loading; payload.data holds the tasks"
+
+    type TaskLoadFailed = Event { error : string, code : string } "Fired when Task fails to load"
+
+  entity Task [runtime] {
+    id : string!
+    title : string @description "task label shown on the bar" @synonyms "name, label, summary, subject" = ""
+    start : datetime @description "task start timestamp the bar is placed from" @synonyms "starts, begins, start date, from"
+    end : datetime @description "task end timestamp the bar is placed to; when absent, duration days are used" @synonyms "finish, due, end date, until"
+    status : "pending" | "active" | "complete" | "blocked" @description "task lifecycle status, drives bar colour" @synonyms "state, stage, phase" = pending
+    group : string @description "group/section the task renders under a header row for" @synonyms "team, swimlane, section, project" = ""
+  }
+
+  trait TaskGanttSchedule -> @rebindable Task [interaction, collection] {
+    initial: loading
+
+    state loading {
+      INIT -> loading
+        (fetch Task {
+          emit: { failure: TaskLoadFailed, success: TaskLoaded }
+          include: @config.include
+        })
+        (render-ui main {
+          align: center
+          children: [{ type: spinner }, {
+            color: muted
+            content: "Loading schedule…"
+            type: typography
+            variant: caption
+          }]
+          className: py-12
+          direction: vertical
+          gap: md
+          type: stack
+        })
+      TaskLoaded -> chart
+        (render-ui main {
+          children: [{
+            align: center
+            children: [{ name: gantt-chart, size: xl, type: icon }, {
+              content: @config.title
+              type: typography
+              variant: h2
+            }]
+            direction: horizontal
+            gap: sm
+            type: stack
+          }, {
+            barClickEvent: @config.onBarClick
+            dayWidth: @config.dayWidth
+            durationField: @config.durationField
+            endField: @config.endField
+            groupField: @config.groupField
+            links: @config.links
+            rangeEnd: @config.rangeEnd
+            rangeStart: @config.rangeStart
+            showToday: @config.showToday
+            startField: @config.startField
+            statusField: @config.statusField
+            tasks: ?data
+            titleField: @config.labelField
+            type: gantt
+          }]
+          direction: vertical
+          gap: lg
+          type: stack
+        })
+      TaskLoadFailed -> error
+        (render-ui main {
+          align: center
+          children: [{
+            color: error
+            name: alert-triangle
+            size: lg
+            type: icon
+          }, {
+            content: "Failed to load"
+            type: typography
+            variant: h3
+          }, {
+            color: muted
+            content: ?error
+            type: typography
+            variant: body
+          }, {
+            action: RETRY
+            icon: rotate-ccw
+            label: Retry
+            type: button
+            variant: primary
+          }]
+          className: py-12
+          direction: vertical
+          gap: md
+          type: stack
+        })
+    }
+
+    state chart {
+      INIT -> loading
+        (fetch Task {
+          emit: { failure: TaskLoadFailed, success: TaskLoaded }
+          include: @config.include
+        })
+        (render-ui main { type: spinner })
+    }
+
+    state error {
+      INIT -> loading
+        (fetch Task {
+          emit: { failure: TaskLoadFailed, success: TaskLoaded }
+          include: @config.include
+        })
+        (render-ui main { type: spinner })
+      RETRY -> loading
+        (fetch Task {
+          emit: { failure: TaskLoadFailed, success: TaskLoaded }
+          include: @config.include
+        })
+        (render-ui main { type: spinner })
+    }
+
+    emits {
+      TaskLoaded
+        @description "Indicates that schedule tasks have been successfully retrieved."
+        @synonyms "loaded, fetched, retrieved, populated"
+        @tier "domain"
+      TaskLoadFailed
+        @description "Indicates a failure to load schedule tasks."
+        @synonyms "error, failed, problem, loading issue"
+        @tier "internal"
+      @config.onBarClick -> external {
+        id : string
+      }
+        @description "Emitted when a gantt bar is clicked; { id } carries the clicked task row's id."
+        @tier "presentation"
+    }
+
+    config {
+      title : string = "Schedule"
+        @label "Title"
+        @description "Header text shown above the gantt chart."
+        @tier "presentation"
+      labelField : string = "title"
+        @label "Label field"
+        @description "Row column holding the bar label. Rebound hosts point this at their own column (e.g. name, summary)."
+        @synonyms "title field, label column, name field"
+        @tier "presentation"
+      startField : string = "start"
+        @label "Start field"
+        @description "Row column holding the start timestamp each bar is placed from (e.g. startTime, startsAt, beginsAt)."
+        @synonyms "start column, from field, begin field"
+        @tier "presentation"
+      endField : string = "end"
+        @label "End field"
+        @description "Row column holding the end timestamp each bar is placed to. When a row has no end, durationField (days) is used instead."
+        @synonyms "end column, due field, finish field"
+        @tier "presentation"
+      durationField : string = ""
+        @label "Duration field"
+        @description "Row column holding the task length in days, used when the row has no end value. Empty = bars always read endField."
+        @synonyms "duration column, length field, days field"
+        @tier "presentation"
+      statusField : string = "status"
+        @label "Status field"
+        @description "Row column holding the status value that drives bar colour."
+        @synonyms "status column, state field, stage field"
+        @tier "presentation"
+      groupField : string = ""
+        @label "Group field"
+        @description "Row column rows are grouped under header rows by (e.g. team, project). Empty (default) = flat list, no group headers."
+        @synonyms "group column, swimlane field, section field"
+        @tier "presentation"
+      rangeStart : string = ""
+        @label "Range start"
+        @description "First visible day (ISO date). Empty (default) = 2 days before the earliest task."
+        @synonyms "window start, axis start, from date"
+        @tier "presentation"
+      rangeEnd : string = ""
+        @label "Range end"
+        @description "Last visible day (ISO date). Empty (default) = 2 days after the latest task end."
+        @synonyms "window end, axis end, to date"
+        @tier "presentation"
+      dayWidth : number = 28
+        @label "Day width"
+        @description "Pixels per day on the time axis."
+        @tier "presentation"
+      showToday : boolean = true
+        @label "Show today marker"
+        @description "Paint the today marker line when today falls inside the visible range."
+        @tier "presentation"
+      links : [GanttLinkSpec] = []
+        @label "Dependency links"
+        @description "Dependency arrows between task ids ({ from, to }); the host derives them from its own relation field and passes them here."
+        @synonyms "dependencies, dependency arrows, precedences"
+        @tier "presentation"
+      include : [string] = []
+        @label "Which relation fields to hydrate?"
+        @description "Entity relation field names to hydrate on fetch, so field mappings can use dot-paths like assignee.name. Empty = no hydration, the default."
+        @synonyms "relation hydration, populate relations, joined fields"
+        @tier "internal"
+      onBarClick : event = ""
+        @label "On bar click"
+        @description "Event emitted when a bar is clicked: UI:{onBarClick} with { id } carrying the clicked row's id. Empty means bars are not clickable."
+        @synonyms "bar click, task click, select task, open task"
+        @tier "presentation"
+    }
+  }
+
+  page "/tasks/gantt" as TaskGanttSchedulePage -> TaskGanttSchedule
+}

package/behaviors/lolo/ui/core/atoms/ui-textarea.lolo

@@ -23,7 +23,7 @@ orbital TextareaOrbital {
 
     emits {
       @config.action -> external { }
-        @description "Declarative event name for trait dispatch"
+        @description "Declarative event: fires on ⌘/Ctrl+Enter with `{ value }`."
         @tier "essential"
       @config.onChange -> external {
         value : string!
@@ -47,7 +47,7 @@ orbital TextareaOrbital {
         @tier "presentation"
       action : event = "ACTION"
         @label "Action"
-        @description "Declarative event name for trait dispatch"
+        @description "Declarative event: fires on ⌘/Ctrl+Enter with `{ value }`."
         @tier "presentation"
       error : string
         @label "Error"