> ## Documentation Index > Fetch the complete documentation index at: https://helloluciallc.com/llms.txt > Use this file to discover all available pages before exploring further. # START HERE - Intelligence Layer **At a glance** The Intelligence Layer is Lucia's decision system. It transforms structured state, operator intent, semantic conversational signals, and live operational context into one calm, truthful next move. *** ## What This Layer Does Lucia’s intelligence layer exists to answer: ```text theme={"dark"} What matters? Why does it matter? What should the operator do next? What can safely wait? ``` It does not exist to produce broad summaries, generic advice, or dashboard sludge. *** ## Primary Intelligence Surface The primary intelligence surface today is: ```text theme={"dark"} Focus Ops ``` Focus Ops is the operator-facing layer where Lucia interprets operational state and returns a focused, low-overwhelm response. *** ## Temporal Spine Doctrine Lucia is situationally aware because she is rooted in arrivals, departures, and stay windows. Calendar is not just a page. Calendar is the root operational reality that anchors the intelligence layer to booking truth. ```text theme={"dark"} Calendar = root operational reality Booking Pulse = granular intelligence lens over booking/calendar reality Signal Stream = what needs attention Lucia Workspace = reasoning partner beside the operator Focus Ops = shared reasoning and conversation Dynamic Action Workspace = action/save surface Full Booking Page = record/review surface Guest-Facing Lucia = public concierge and claim/signal bridge Eval Labs = behavioral proof and regression protection ``` This doctrine keeps Lucia from becoming a generic chat surface. The intelligence layer reasons over booking reality first. *** ## Workspace Context Doctrine Lucia is no longer dashboard-bound. The intelligence layer now supports Lucia as a context-aware operator companion beside the workspace. The operator can move through Calendar, Signal Stream, DAW, Full Booking, Tasks, Concierge, Maintenance, and Reconciliation while keeping the same Lucia conversation alive. Lucia can answer: ```text theme={"dark"} What am I looking at? What should I do here? What matters for this booking? What should I pay attention to here? Now what? ``` Current Engine behavior uses `active_context.workspace` to orient responses to the current surface. Explicit prompt subject still wins over page context, and operator-facing responses must not expose raw implementation language such as active\_context, current\_surface, payload, or metadata. The cockpit distinction is: ```text theme={"dark"} Lucia Workspace + DAW = cockpit Full Booking Page = record/review surface ``` *** ## Guest-Facing Intelligence Doctrine Guest-facing Lucia is a separate public-facing concierge surface, not the same thing as operator Focus Ops. Guest-facing intelligence should answer: ```text theme={"dark"} How can I help this guest safely? What relationship is the guest claiming? What can be answered without verification? What claim fragments are useful for verification? What operator-visible signal should be created? ``` Guest-facing Lucia may be warm, helpful, and conversational before verification. She must not turn weak evidence into booking truth. The deterministic layer owns: ```text theme={"dark"} identity_state verification_state linkage_state booking-private data access signal signing and intake mutation boundaries ``` The model may express hospitality, ask for the smallest useful claim, and explain safe next steps. *** ## v0.1.3.6 Alignment Lucia Engine v0.1.3.6 uses `gpt-5.6-sol` (GPT-5.6 Sol) as the default model. Lucia JSON gateway calls run through the OpenAI Responses API, while deterministic contracts still own truth-state, route shape, and operator-safe boundaries. Focus Ops now includes [06 - Semantic Conversational Intent Assist](/lucia/intelligence/semantic-conversational-intent-assist), a live sublayer for semantic lightweight utility and conversational intent classification. GPT-5.6 Sol response refinement now sits over verified context packs with truth/routing guardrails. The model may explain, interpret, and contain. The deterministic layer owns guest identity, booking IDs, stay windows, payment state, task status, route/action safety, save/completion truth, and guest-facing identity/linkage state. The `/admin/operator-focus` response carries runtime identity and model-execution provenance inside `meta` without changing the stable top-level `ok / data / meta` contract. Consumers can distinguish model invocation from no-attempt deterministic execution, verify successful provider task evidence, and read fallback as an independent state instead of inferring model use from the configured default. This is not phrase patching. It protects whole prompt families by meaning, while keeping Lucia bounded to operator guidance. Core doctrine: ```text theme={"dark"} Human first. Purpose second. Boundary third. ``` *** ## Current Live-Dev Product Pillar The current Development runtime is organized around: ```text theme={"dark"} Workspace OS / context-aware operator companion Signal → Action → Save → Reminder loop Guest signal → Operator review/link/action loop Stripe movement truth → durable ledger → payment attention judgment → Admin read-only rendering ``` In product terms: ```text theme={"dark"} Infinite real-world property tasks. Finite beautiful action workspaces. Lucia routes the human to the right one. ``` The live-dev loop is: ```text theme={"dark"} Calendar / booking spine → Booking Pulse → Signal Stream → Lucia Workspace / Focus with Lucia → real reminder persistence → due resurfacing → Open Reminder → Got it / re-remind / dismiss / move-to-top → newest meaningful attention event wins → Resolver Matrix → Dynamic Action Workspace Calendar booking click → Full Booking Page for booking record/review Guest-facing Lucia → identity orientation → claim collection → guest operational signal → operator review/link/action when safe ``` This is Development/live-dev runtime truth, not a production-readiness claim. *** ## Core Responsibilities ### 1. Intent Recognition Lucia must understand what kind of help the operator is asking for. Examples: ```text theme={"dark"} priority_triage upcoming_arrivals deferral human_utility maintenance_focus ``` v0.1.3.6 extends this with semantic conversational intent assist so small human prompts, lightweight utility questions, and scoped property-context questions are handled by meaning rather than exact wording. *** ### 2. Operational Ranking Lucia must rank live operational signals. Current examples: ```text theme={"dark"} arrival departure stay window maintenance issue payment review confirmed financial truth upcoming check-in concierge risk open task ``` Current payment attention truth: ```text theme={"dark"} LIEA consumes Stripe financial truth for payment attention suppression. Confirmed-paid Harper Quinn #29110012 no longer remains a payment blocker. Arrival readiness remains separate when arrival details are still missing. LIEA does not yet consume durable property payment policy truth. Signal Stream is not yet wired to LIEA. ``` See [Lucia Payment Truth Foundation](/lucia/system-architecture/lucia-payment-truth-foundation) for the current payment truth architecture. The newest meaningful attention event owns the top of the Signal Stream unless dismissed. A user Move-to-top command and Lucia reminder resurfacing are both attention-shaping events. *** ### 3. Emotional Containment Lucia must reduce operator stress. This means: ```text theme={"dark"} fewer options clearer action calmer tone truthful scope ``` Finite action workspaces are part of containment: Lucia should route the operator into the right focused workspace instead of making the operator hunt through the whole system. *** ### 4. Output Refinement Lucia must convert reasoning into language that feels useful, not robotic. Good output: ```text theme={"dark"} First priority is Ava Sterling’s reported plumbing leak in the primary suite bathroom. It needs immediate maintenance attention, with payment review still pending and check-in tomorrow. ``` Bad output: ```text theme={"dark"} There are several items requiring attention across operational domains. ``` *** ## The Rule ```text theme={"dark"} One highest-leverage next move beats ten correct observations. ``` *** ## Relationship to Other Layers ```text theme={"dark"} Ingestion Layer → supplies external signals System Architecture → defines runtime paths Intelligence Layer → decides what matters Operations Layer → turns decisions into work Evaluation Layer → tests quality and drift Guest-Facing Lucia → collects public guest context safely ``` *** ## Non-Negotiables Lucia must never: * overstate certainty * invent system actions * flatten urgency * bury the lead * give the operator more work than necessary *** ## See Also * [02 - Focus Ops Intelligence](/lucia/intelligence/focus-ops-intelligence) * [01 - Intent System](/lucia/intelligence/intent-system) * [06 - Semantic Conversational Intent Assist](/lucia/intelligence/semantic-conversational-intent-assist) * [03 - Reasoning Model](/lucia/intelligence/reasoning-model) * [04 - Output Refinement System](/lucia/intelligence/output-refinement-system) * [05 - Emotional Containment System](/lucia/intelligence/emotional-containment-system) * [00 - START HERE - Guest-Facing Lucia](/lucia/guest-facing-lucia/start-here-guest-facing-lucia) * [04 - Lucia Workspace OS Milestone](/lucia/system-architecture/lucia-workspace-os-milestone) * [00 - START HERE - Evaluation System](/lucia/evaluation/start-here-evaluation-system) *** ## Upstream / Downstream ### Upstream This layer is fed by: * [02 - Current System State](/lucia/start-here-lucia-ai/current-system-state) * [00 - START HERE - System Architecture](/lucia/system-architecture/start-here-system-architecture) ### Downstream This layer affects: * [00 - START HERE - Operations](/lucia/operations/start-here-operations) * [00 - START HERE - Evaluation System](/lucia/evaluation/start-here-evaluation-system) * [Lucia Decision Log](/lucia/decisions/lucia-decision-log)