@almadar/std 16.144.0 → 16.146.0

package/behaviors/lolo/ml/atoms/std-ml-similarity.lolo

@@ -0,0 +1,166 @@
+app std-ml-similarity "1.0.0"
+"Retrieval rung (R3) — embed a candidate against references and gate on cosine floor + margin; abstains when not confident."
+
+orbital MlSimilarityOrbital {
+
+  entity SimilarityComparison [runtime] {
+    query            : string    = ""
+    candidates       : [string]  = []
+    embeddings       : [[float]] = []
+    queryVector      : [float]   = []
+    candidateVectors : [[float]] = []
+    matchIndex       : int       = 0
+    matchScore       : float     = 0
+    matchMargin      : float     = 0
+    reason           : string    = ""
+    request          : object    = {}
+    status           : "idle" | "embedding" | "resolved" = idle
+  }
+
+  trait SimilarityRun -> SimilarityComparison [lifecycle, instance] {
+    initial: idle
+
+    config {
+      floor : float = 0.82
+        @label "Match floor"
+        @description "Minimum cosine score for a confident match"
+        @tier "policy"
+      margin : float = 0.05
+        @label "Match margin"
+        @description "Minimum gap between the best and second-best score required to trust the match"
+        @tier "policy"
+      embedModel : string = ""
+        @label "Embedding model"
+        @description "Reserved for embedding-model selection; llm/embed takes only a texts array today, so this knob is not yet wired into the call"
+        @tier "infra"
+    }
+
+    state idle {
+      INIT -> idle
+        (set @entity.query "")
+        (set @entity.candidates [])
+        (set @entity.embeddings [])
+        (set @entity.queryVector [])
+        (set @entity.candidateVectors [])
+        (set @entity.matchIndex 0)
+        (set @entity.matchScore 0)
+        (set @entity.matchMargin 0)
+        (set @entity.reason "")
+        (set @entity.request {})
+        (set @entity.status idle)
+
+      COMPARE -> embedding when (> (array/len ?candidates) 0)
+        (set @entity.query ?query)
+        (set @entity.candidates ?candidates)
+        (set @entity.request ?request)
+        (set @entity.status embedding)
+        (llm/embed (array/prepend ?candidates ?query) { emit: { success: EMBEDDED, failure: EMBED_FAILED } })
+
+      COMPARE -> resolved when (== (array/len ?candidates) 0)
+        (set @entity.query ?query)
+        (set @entity.candidates [])
+        (set @entity.embeddings [])
+        (set @entity.queryVector [])
+        (set @entity.candidateVectors [])
+        (set @entity.matchIndex 0)
+        (set @entity.matchScore 0)
+        (set @entity.matchMargin 0)
+        (set @entity.reason "empty candidate list")
+        (set @entity.request ?request)
+        (set @entity.status resolved)
+        (emit SIMILARITY_ABSTAINED { reason: "empty candidate list", request: @entity.request })
+    }
+
+    state embedding {
+      EMBEDDED -> resolved
+        (set @entity.embeddings ?result)
+        (set @entity.status resolved)
+        ;; An embed result without query + at least one candidate vector is an
+        ;; abstain, not a crash — the rung can prove nothing from it.
+        (if (< (array/len ?result) 2)
+          (do
+            (set @entity.queryVector [])
+            (set @entity.candidateVectors [])
+            (set @entity.matchIndex 0)
+            (set @entity.matchScore 0)
+            (set @entity.matchMargin 0)
+            (set @entity.reason "embedding result incomplete")
+            (emit SIMILARITY_ABSTAINED { reason: "embedding result incomplete", request: @entity.request }))
+          (do
+            (set @entity.queryVector (array/first @entity.embeddings))
+            (set @entity.candidateVectors (array/drop @entity.embeddings 1))
+            (let ((nearest (array/nearest @entity.queryVector @entity.candidateVectors)))
+              (do
+                (set @entity.matchIndex (object/get @nearest "index"))
+                (set @entity.matchScore (object/get @nearest "score"))
+                (set @entity.matchMargin (object/get @nearest "margin"))
+                (if (and (>= @entity.matchScore @config.floor) (>= @entity.matchMargin @config.margin))
+                    (do
+                      (set @entity.reason "")
+                      (emit SIMILARITY_MATCHED { index: @entity.matchIndex, score: @entity.matchScore }))
+                    (do
+                      (set @entity.reason (if (< @entity.matchScore @config.floor) "below floor" "thin margin"))
+                      (emit SIMILARITY_ABSTAINED { reason: @entity.reason, request: @entity.request })))))))
+
+      EMBED_FAILED -> resolved
+        (set @entity.embeddings [])
+        (set @entity.queryVector [])
+        (set @entity.candidateVectors [])
+        (set @entity.matchIndex 0)
+        (set @entity.matchScore 0)
+        (set @entity.matchMargin 0)
+        (set @entity.reason "embedding unavailable")
+        (set @entity.status resolved)
+        (emit SIMILARITY_ABSTAINED { reason: "embedding unavailable", request: @entity.request })
+    }
+
+    state resolved {
+      INIT -> resolved
+        (set @entity.status resolved)
+      RESET -> idle
+        (set @entity.query "")
+        (set @entity.candidates [])
+        (set @entity.embeddings [])
+        (set @entity.queryVector [])
+        (set @entity.candidateVectors [])
+        (set @entity.matchIndex 0)
+        (set @entity.matchScore 0)
+        (set @entity.matchMargin 0)
+        (set @entity.reason "")
+        (set @entity.request {})
+        (set @entity.status idle)
+    }
+
+    emits {
+      EMBEDDED {
+        result : [[float]]!
+      }
+        @description "Raw embeddings from llm/embed — query vector at index 0, candidate vectors following in input order"
+        @tier "secondary"
+
+      SIMILARITY_MATCHED -> external {
+        index : int!
+        score : float!
+      }
+        @description "Candidate matched with high confidence — score at or above floor, with a clear margin over the runner-up"
+        @tier "primary"
+
+      SIMILARITY_ABSTAINED -> external {
+        reason : string!
+        request : object
+      }
+        @description "No confident match — reason is one of: empty candidate list, below floor, thin margin, embedding unavailable. request echoes the originating request untouched so the next rung can project its own inputs out of it"
+        @tier "primary"
+    }
+
+    listens {
+      COMPARE {
+        query : string!
+        candidates : [string]!
+        request : object
+      }
+    }
+  }
+
+  page "/ml-similarity" as MlSimilarityPage -> SimilarityRun
+}

package/behaviors/lolo/ml/molecules/std-escalating-decision.lolo

@@ -0,0 +1,271 @@
+app std-escalating-decision "1.0.0"
+"std-escalating-decision — the intelligence ladder itself, as one reusable composition. One request enters at DECIDE and falls through the rungs in order — R0 exact check, R1 table lookup, R3 retrieval, R4 learned inference, R5 generative classification — each rung handing off to the next by abstaining, until one proves the answer. Exits DECIDED, tagged with which rung answered (rung, confidence, matched, reasoning), or DECISION_FAILED if even the generative floor could not serve it. The escalation is a chain, not a hub: each rung listens directly to the rung above it and projects its own inputs out of the carried request, so the trait graph is a DAG and no event ever returns to a rung that already ran. Domain-agnostic: it knows about candidates and categories, not students or quizzes — grading, routing, matching, moderation, and duplicate detection are all this same molecule with different knobs. R2 (the Beta posterior) is deliberately not in this chain: it is the 'decide what to do next' half of a turn and already lives in std-knowledge-tracing."
+
+orbital EscalatingDecisionOrbital {
+  uses Rung0 from "std/behaviors/std-ml-exact-check"
+  uses Rung1 from "std/behaviors/std-ml-lookup"
+  uses Rung3 from "std/behaviors/std-ml-similarity"
+  uses Rung4 from "std/behaviors/std-ml-infer"
+  uses Rung5 from "std/behaviors/std-ml-classify"
+
+  ;; The entry holds no request data: the whole DECIDE payload travels down
+  ;; the chain as `request`, so there is nothing for this trait to remember.
+  entity LadderRequest [runtime] {
+    status : "idle" | "dispatched" = idle
+  }
+
+  ;; `matched` is deliberately absent: it is an exact key, a table entry, a
+  ;; match index, a tensor, or a category label depending on which rung served
+  ;; the request. `any` is honest in payload position but lowers to `string` in
+  ;; entity position (C-LOLO-ANY-LOWERS-TO-STRING), so the value is carried on
+  ;; the DECIDED payload only, never mirrored onto this entity as a lie.
+  entity LadderVerdict [runtime] {
+    rung       : string = ""
+    confidence : number = 0
+    reasoning  : string = ""
+    failReason : string = ""
+    status     : "idle" | "decided" | "failed" = idle
+  }
+
+  entity ExactCheck [runtime] {
+    matched : boolean = false
+    status  : "idle" | "checked" = idle
+  }
+
+  entity KeyLookup [runtime] {
+    matched : boolean = false
+    status  : "idle" | "checked" = idle
+  }
+
+  entity SimilarityComparison [runtime] {
+    query            : string    = ""
+    candidates       : [string]  = []
+    embeddings       : [[float]] = []
+    queryVector      : [float]   = []
+    candidateVectors : [[float]] = []
+    matchIndex       : int       = 0
+    matchScore       : float     = 0
+    matchMargin      : float     = 0
+    reason           : string    = ""
+    request          : object    = {}
+    status           : "idle" | "embedding" | "resolved" = idle
+  }
+
+  entity Inference [runtime] {
+    input      : object   = {}
+    output     : [float]  = []
+    confidence : float    = 0
+    violations : [object] = []
+    reason     : string   = ""
+    request    : object   = {}
+    status     : "idle" | "inferring" | "resolved" = idle
+  }
+
+  entity ClassifierVerdict [runtime] {
+    text         : string   = ""
+    category     : string   = ""
+    confidence   : float    = 0
+    reasoning    : string   = ""
+    errorMessage : string   = ""
+    request      : object   = {}
+    status       : "idle" | "classifying" | "done" = idle
+  }
+
+  ;; The ladder's entry. Holds nothing the rungs need — the whole DECIDE
+  ;; payload travels down the chain as `request`, and each rung projects its
+  ;; own inputs out of it. This trait listens to no rung, which is what keeps
+  ;; the graph acyclic.
+  trait LadderEntry -> LadderRequest [lifecycle, instance] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+        (set @entity.status idle)
+
+      DECIDE -> dispatched
+        (set @entity.status dispatched)
+        (emit RUN_EXACT { candidate: ?candidate, key: ?key, request: ? })
+    }
+
+    state dispatched {
+      INIT -> dispatched
+        (set @entity.status dispatched)
+      RESET -> idle
+        (set @entity.status idle)
+    }
+
+    emits {
+      RUN_EXACT {
+        candidate : any!
+        key : any!
+        request : object!
+      }
+        @description "Starts the ladder at the exact-check rung (R0). request is the whole DECIDE payload, carried down the chain so each rung can project its own inputs."
+        @tier "secondary"
+    }
+
+    listens {
+      DECIDE {
+        candidate  : any!
+        key        : any!
+        accepted   : [any]!
+        categories : [string]!
+      }
+        @description "Public entry point — decide the candidate, falling through the ladder until a rung can prove the answer. accepted is R1's table; categories is R3's comparison set (R5's closed label set is the ClassifyRung categories knob, a design-time decision rather than a per-request one)."
+        @tier "primary"
+    }
+  }
+
+  trait ExactRung = Rung0.traits.ExactCheckRun -> ExactCheck {
+    listens {
+      LadderEntry.RUN_EXACT -> CHECK
+    }
+  }
+
+  trait LookupRung = Rung1.traits.LookupRun -> KeyLookup {
+    listens {
+      ExactRung.EXACT_UNMATCHED -> LOOKUP
+        with { candidate: ?candidate, accepted: (object/get ?request "accepted"), request: ?request }
+    }
+  }
+
+  trait SimilarityRung = Rung3.traits.SimilarityRun -> SimilarityComparison {
+    listens {
+      LookupRung.KEY_MISS -> COMPARE
+        with { query: (str/concat ?candidate), candidates: (object/get ?request "categories"), request: ?request }
+    }
+  }
+
+  trait InferRung = Rung4.traits.InferenceRun -> Inference {
+    listens {
+      SimilarityRung.SIMILARITY_ABSTAINED -> INFER
+        with { input: ?request, request: ?request }
+    }
+  }
+
+  trait ClassifyRung = Rung5.traits.ClassifyRun -> ClassifierVerdict {
+    listens {
+      InferRung.INFER_ABSTAINED -> CLASSIFY
+        with { text: (str/concat (object/get ?request "candidate")), request: ?request }
+    }
+  }
+
+  ;; The sink. Listens to every rung's success plus the generative floor's
+  ;; failure, and emits the one public verdict. Nothing listens to it, so it
+  ;; closes the DAG.
+  trait LadderVerdictSink -> LadderVerdict [lifecycle, instance] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+        (set @entity.rung "")
+        (set @entity.confidence 0)
+        (set @entity.reasoning "")
+        (set @entity.failReason "")
+        (set @entity.status idle)
+
+      FROM_EXACT -> decided
+        (set @entity.rung "R0")
+        (set @entity.confidence 1)
+        (set @entity.reasoning "")
+        (set @entity.status decided)
+        (emit DECIDED { rung: "R0", confidence: 1, matched: ?key, reasoning: "" })
+
+      FROM_LOOKUP -> decided
+        (set @entity.rung "R1")
+        (set @entity.confidence 1)
+        (set @entity.reasoning "")
+        (set @entity.status decided)
+        (emit DECIDED { rung: "R1", confidence: 1, matched: ?entry, reasoning: "" })
+
+      FROM_SIMILARITY -> decided
+        (set @entity.rung "R3")
+        (set @entity.confidence ?score)
+        (set @entity.reasoning "")
+        (set @entity.status decided)
+        (emit DECIDED { rung: "R3", confidence: ?score, matched: ?index, reasoning: "" })
+
+      FROM_INFER -> decided
+        (set @entity.rung "R4")
+        (set @entity.confidence ?confidence)
+        (set @entity.reasoning "")
+        (set @entity.status decided)
+        (emit DECIDED { rung: "R4", confidence: ?confidence, matched: ?output, reasoning: "" })
+
+      FROM_CLASSIFY -> decided
+        (set @entity.rung "R5")
+        (set @entity.confidence ?confidence)
+        (set @entity.reasoning ?reasoning)
+        (set @entity.status decided)
+        (emit DECIDED { rung: "R5", confidence: ?confidence, matched: ?category, reasoning: ?reasoning })
+
+      FROM_CLASSIFY_FAILURE -> failed
+        (set @entity.failReason ?error)
+        (set @entity.status failed)
+        (emit DECISION_FAILED { reason: ?error })
+    }
+
+    state decided {
+      INIT -> decided
+        (set @entity.status decided)
+      RESET -> idle
+        (set @entity.rung "")
+        (set @entity.confidence 0)
+        (set @entity.reasoning "")
+        (set @entity.failReason "")
+        (set @entity.status idle)
+    }
+
+    state failed {
+      INIT -> failed
+        (set @entity.status failed)
+      RESET -> idle
+        (set @entity.rung "")
+        (set @entity.confidence 0)
+        (set @entity.reasoning "")
+        (set @entity.failReason "")
+        (set @entity.status idle)
+    }
+
+    emits {
+      DECIDED -> external {
+        rung : string!
+        confidence : number!
+        matched : any!
+        reasoning : string!
+      }
+        @description "The ladder proved an answer. rung names which one served it: R0 exact, R1 table, R3 retrieved, R4 learned, R5 generative."
+        @tier "primary"
+
+      DECISION_FAILED -> external {
+        reason : string!
+      }
+        @description "Even the generative floor (R5) could not answer — the classify service call itself failed."
+        @tier "primary"
+    }
+
+    listens {
+      FROM_EXACT { key : any! }
+      FROM_LOOKUP { entry : any! }
+      FROM_SIMILARITY { index : int!  score : float! }
+      FROM_INFER { output : [float]!  confidence : float! }
+      FROM_CLASSIFY { category : string!  confidence : float!  reasoning : string! }
+      FROM_CLASSIFY_FAILURE { error : string! }
+
+      ExactRung.EXACT_MATCHED -> FROM_EXACT
+        with { key: ?key }
+      LookupRung.KEY_HIT -> FROM_LOOKUP
+        with { entry: ?entry }
+      SimilarityRung.SIMILARITY_MATCHED -> FROM_SIMILARITY
+        with { index: ?index, score: ?score }
+      InferRung.INFERRED -> FROM_INFER
+        with { output: ?output, confidence: ?confidence }
+      ClassifyRung.CLASSIFIED -> FROM_CLASSIFY
+        with { category: ?category, confidence: ?confidence, reasoning: ?reasoning }
+      ClassifyRung.CLASSIFY_FAILED -> FROM_CLASSIFY_FAILURE
+        with { error: ?error }
+    }
+  }
+
+  page "/ladder/decide" as LadderDecidePage -> LadderEntry, ExactRung, LookupRung, SimilarityRung, InferRung, ClassifyRung, LadderVerdictSink
+}

package/behaviors/lolo/ml/molecules/std-knowledge-tracing.lolo

@@ -0,0 +1,115 @@
+app std-knowledge-tracing "1.0.0"
+"std-knowledge-tracing — turns one true/false observation ('did the learner get this right?') into a tracked belief about mastery, and captures the same observation as a labeled training example in the same motion. Composes std-ml-posterior (the R2 statistical rung — a Beta-Bernoulli belief over an unknown success rate) with std-ml-label-capture: every posterior verdict — MASTERY_REACHED, REMEDIATION_NEEDED, or the abstain EVIDENCE_INSUFFICIENT — becomes a persisted labeled example (the input skill, the posterior's own verdict, and the ground-truth outcome that produced it), so a cheaper rung can later be trained to reproduce the same call without running the statistics. Domain-agnostic: it knows about skills and observations, not students, quizzes, or courses. One instance tracks one belief (e.g. one learner × one skill); the host composes as many instances as it has beliefs to hold."
+orbital KnowledgeTracingOrbital {
+  uses Posterior from "std/behaviors/std-ml-posterior"
+  uses LabelCap from "std/behaviors/std-ml-label-capture"
+
+  entity KnowledgeState [runtime, shared] {
+    skillId : string = ""
+    lastOutcome : boolean = false
+    alpha : float = 1
+    beta : float = 1
+    mean : float = 0
+    intervalLow : float = 0
+    intervalHigh : float = 0
+    observations : int = 0
+    status : "idle" | "insufficient" | "mastered" | "remediate" = idle
+    input : json = null
+    verdict : json = null
+    source : string = ""
+    outcome : json = null
+    sink : string = ""
+    recordedAt : number = 0
+  }
+
+  trait ObservationRelay -> KnowledgeState [lifecycle, instance] {
+    initial: idle
+
+    state idle {
+      INIT -> idle
+        (set @entity.skillId "")
+        (set @entity.lastOutcome false)
+      OBSERVE_SKILL -> idle
+        (set @entity.skillId ?skillId)
+        (set @entity.lastOutcome ?outcome)
+        (emit OBSERVATION_MADE { outcome: ?outcome })
+      VERDICT_REACHED -> idle
+        (emit CAPTURE_LABEL {
+          input: { skillId: @entity.skillId },
+          verdict: { status: ?status, mean: ?mean, intervalLow: ?intervalLow, intervalHigh: ?intervalHigh },
+          source: "posterior",
+          outcome: @entity.lastOutcome
+        })
+    }
+
+    emits {
+      OBSERVATION_MADE {
+        outcome : boolean!
+      }
+        @description "Forwards the raw outcome to PosteriorTracker once skillId is recorded on the shared entity."
+        @tier "secondary"
+
+      CAPTURE_LABEL {
+        input : any!
+        verdict : any!
+        source : string!
+        outcome : any
+      }
+        @description "The posterior's verdict reshaped into a labeled example for LabelCaptureListener."
+        @tier "secondary"
+    }
+
+    listens {
+      OBSERVE_SKILL {
+        skillId : string!
+        outcome : boolean!
+      }
+        @description "Public entry point — one true/false observation of a learner against one skill."
+        @tier "primary"
+
+      PosteriorTracker.MASTERY_REACHED -> VERDICT_REACHED
+        with { status: "mastered", mean: ?mean, intervalLow: ?intervalLow, intervalHigh: ?intervalHigh }
+      PosteriorTracker.REMEDIATION_NEEDED -> VERDICT_REACHED
+        with { status: "remediate", mean: ?mean, intervalLow: ?intervalLow, intervalHigh: ?intervalHigh }
+      PosteriorTracker.EVIDENCE_INSUFFICIENT -> VERDICT_REACHED
+        with { status: "insufficient", mean: ?mean, intervalLow: ?intervalLow, intervalHigh: ?intervalHigh }
+
+      VERDICT_REACHED {
+        status : string!
+        mean : float!
+        intervalLow : float!
+        intervalHigh : float!
+      }
+        @description "Any posterior verdict, tagged with which one it was."
+        @tier "secondary"
+    }
+  }
+
+  trait PosteriorTracker = Posterior.traits.PosteriorBelief -> KnowledgeState {
+    config {
+      priorAlpha: 1
+      priorBeta: 1
+      masteryFloor: 0.85
+      remediationCeiling: 0.35
+      intervalWidthMax: 0.25
+      sampleCount: 200
+    }
+
+    listens {
+      ObservationRelay.OBSERVATION_MADE -> OBSERVE
+    }
+  }
+
+  trait Labels = LabelCap.traits.LabelCaptureListener -> KnowledgeState {
+    config {
+      sink: "knowledge-tracing"
+      sampleRate: 1
+    }
+
+    listens {
+      ObservationRelay.CAPTURE_LABEL -> CAPTURE
+    }
+  }
+
+  page "/knowledge-tracing" as KnowledgeTracingPage -> ObservationRelay, PosteriorTracker, Labels
+}

package/behaviors/lolo/ui/core/atoms/std-app-layout.lolo

@@ -43,6 +43,7 @@ orbital AppLayoutOrbital {
             searchEvent: @config.searchEvent
             topBarActions: @config.topBarActions
             type: @config.layoutPattern
+            user: (if @config.viewerName { avatar: @config.viewerAvatar, email: @config.viewerEmail, name: @config.viewerName } null)
           }]
         })
       AppLayoutStateLoaded -> composing
@@ -94,6 +95,19 @@ orbital AppLayoutOrbital {
         @description "Name shown in the top-left of the chrome header."
         @synonyms "app title, product name, brand name, application name, site name"
         @tier "presentation"
+      viewerName : string = ""
+        @label "Who is signed in"
+        @description "Display name of the signed-in viewer, shown in the app bar's account menu — typically @user.name. Blank renders no account menu, so people can see which account (and which persona) they are viewing the app as only when it is actually known."
+        @synonyms "signed in user, current user, account, profile, persona, who am i"
+        @tier "presentation"
+      viewerEmail : string = ""
+        @label "Signed-in email"
+        @description "Email shown under the name in the account menu — typically @user.email."
+        @tier "presentation"
+      viewerAvatar : string = ""
+        @label "Signed-in avatar"
+        @description "Avatar image URL for the account menu."
+        @tier "presentation"
       navItems : [NavItem] = []
         @label "Which sections appear in the sidebar?"
         @description "Top-level navigation links shown on the left rail."

package/behaviors/lolo/ui/core/atoms/std-board.lolo

@@ -62,6 +62,17 @@ orbital BoardOrbital {
           title: "Failed to load board"
           type: error-state
         })
+      ;; Card move/delete and add-card save all land here from their own
+      ;; states; without this the persist success is dropped and the spinner
+      ;; never resolves (only the failure twin below used to recover).
+      BoardItemsSaved -> loading
+        (fetch BoardView {
+          emit: { failure: BoardItemsLoadFailed, success: BoardItemsLoaded }
+        })
+        (render-ui main {
+          title: "Refreshing board…"
+          type: loading-state
+        })
       BoardItemsSaveFailed -> error
         (set @entity.errorMessage ?error)
         (render-ui main {
@@ -81,10 +92,10 @@ orbital BoardOrbital {
           type: loading-state
         })
       OPEN_CARD -> viewing_card
-        (set @entity.currentId ?row.id)
-        (set @entity.currentTitle ?row.title)
-        (set @entity.currentDescription ?row.description)
-        (set @entity.currentStage ?row.stage)
+        (set @entity.currentId ?id)
+        (set @entity.currentTitle ?title)
+        (set @entity.currentDescription ?description)
+        (set @entity.currentStage ?stage)
         (set @entity.currentNotes ?row.notes)
         (render-ui main {
           children: [{
@@ -362,6 +373,9 @@ orbital BoardOrbital {
       OPEN_CARD {
         id : string!
         row : object!
+        title : string
+        description : string
+        stage : string
       }
         @description "A card within the board has been selected or activated."
         @synonyms "select, activate, view, show"
@@ -558,7 +572,7 @@ orbital BoardOrbital {
                       align: center
                       children: [{
                         action: OPEN_CARD
-                        actionPayload: { id: @config.cardIdBinding, row: @item }
+                        actionPayload: { description: @config.cardDescriptionBinding, id: @config.cardIdBinding, row: @item, stage: @config.cardStageBinding, title: @config.cardTitleBinding }
                         icon: arrow-right
                         label: Open
                         type: button
@@ -670,7 +684,7 @@ orbital BoardOrbital {
                         variant: primary
                       }, {
                         action: OPEN_CARD
-                        actionPayload: { id: @config.cardIdBinding, row: @item }
+                        actionPayload: { description: @config.cardDescriptionBinding, id: @config.cardIdBinding, row: @item, stage: @config.cardStageBinding, title: @config.cardTitleBinding }
                         className: ml-auto
                         icon: arrow-right
                         label: Open