From 0d273c5641f31b9cd5c15bfe10f2281617145296 Mon Sep 17 00:00:00 2001 From: Jan De Landtsheer Date: Tue, 21 Apr 2026 20:29:40 +0200 Subject: [PATCH 01/23] docs: ADR 0001 + Phase 1-4 implementation plans Pluggable storage backend, network access, and emergent domain classification. Introduces MemoryStore + Embedder traits, PgMemoryStore alongside SqliteMemoryStore, HTTP MCP + API key auth, and HDBSCAN-based domain clustering. Phase 5 federation deferred to a follow-up ADR. - docs/adr/0001-pluggable-storage-and-network-access.md -- Accepted - docs/plans/0001-phase-1-storage-trait-extraction.md - docs/plans/0002-phase-2-postgres-backend.md - docs/plans/0003-phase-3-network-access.md - docs/plans/0004-phase-4-emergent-domain-classification.md - docs/prd/001-getting-centralized-vestige.md -- source RFC --- ...01-pluggable-storage-and-network-access.md | 303 ++++ .../0001-phase-1-storage-trait-extraction.md | 1026 ++++++++++++ docs/plans/0002-phase-2-postgres-backend.md | 1269 +++++++++++++++ docs/plans/0003-phase-3-network-access.md | 1435 +++++++++++++++++ ...-phase-4-emergent-domain-classification.md | 883 ++++++++++ docs/prd/001-getting-centralized-vestige.md | 751 +++++++++ 6 files changed, 5667 insertions(+) create mode 100644 docs/adr/0001-pluggable-storage-and-network-access.md create mode 100644 docs/plans/0001-phase-1-storage-trait-extraction.md create mode 100644 docs/plans/0002-phase-2-postgres-backend.md create mode 100644 docs/plans/0003-phase-3-network-access.md create mode 100644 docs/plans/0004-phase-4-emergent-domain-classification.md create mode 100644 docs/prd/001-getting-centralized-vestige.md diff --git a/docs/adr/0001-pluggable-storage-and-network-access.md b/docs/adr/0001-pluggable-storage-and-network-access.md new file mode 100644 index 0000000..c150c70 --- /dev/null +++ b/docs/adr/0001-pluggable-storage-and-network-access.md @@ -0,0 +1,303 @@ +# ADR 0001: Pluggable Storage Backend, Network Access, and Emergent Domains + +**Status**: Accepted +**Date**: 2026-04-21 +**Related**: [docs/prd/001-getting-centralized-vestige.md](../prd/001-getting-centralized-vestige.md) + +--- + +## Context + +Vestige v2.x runs as a per-machine local process: stdio MCP transport, SQLite + +FTS5 + USearch HNSW in `~/.vestige/`, fastembed locally for embeddings. This is +ideal for single-machine single-agent use but blocks three real needs: + +- **Multi-machine access** -- same memory brain from laptop, desktop, server +- **Multi-agent access** -- multiple AI clients against one store concurrently +- **Future federation** -- syncing memory between decentralized nodes (MOS / + Threefold grid) + +SQLite's single-writer model and lack of a native network protocol make it +unsuitable as a centralized server. PostgreSQL + pgvector collapses our three +storage layers (SQLite, FTS5, USearch) into one engine with MVCC concurrency, +auth, and replication. + +Separately, Vestige today has no notion of domain or project scope -- all memories +share one namespace. For a multi-machine brain, users want soft topical +boundaries ("dev", "infra", "home") without manual tenanting. HDBSCAN clustering +on embeddings produces these boundaries from the data itself. + +The PRD at `docs/prd/001-getting-centralized-vestige.md` sketches the full design. +This ADR records the architectural decisions and resolves the open questions from +that document. + +--- + +## Decision + +Introduce two new trait boundaries, a network transport layer, and a domain +classification module. All four changes ship in parallel phases. + +**Trait boundaries:** + +1. `MemoryStore` -- single trait covering CRUD, hybrid search, FSRS scheduling, + graph edges, and domains. One big trait, not four. +2. `Embedder` -- separate trait for text-to-vector encoding. Storage never calls + fastembed directly. Callers (cognitive engine locally, HTTP server remotely) + compute embeddings and pass them into the store. + +**Backends:** + +- `SqliteMemoryStore` -- existing code refactored behind the trait, no behavior + change. +- `PgMemoryStore` -- new, using sqlx + pgvector + tsvector. Selectable at runtime + via `vestige.toml`. + +**Network:** + +- MCP over Streamable HTTP on the existing Axum server. +- API key auth middleware (blake3-hashed, stored in `api_keys` table). +- Dashboard uses the same API keys for login, then signed session cookies for + subsequent requests. + +**Domain classification:** + +- HDBSCAN clustering over embeddings to discover domains automatically. +- Soft multi-domain assignment -- raw similarity scores stored per memory, every + domain above a threshold is assigned. +- Conservative drift handling -- propose splits/merges, never auto-apply. + +--- + +## Architecture Overview + +### Component Breakdown + +1. **`Embedder` trait** (new module `crates/vestige-core/src/embedder/`) + - `async fn embed(&self, text: &str) -> Result>` + - `fn model_name(&self) -> &str` + - `fn dimension(&self) -> usize` + - Impls: `FastembedEmbedder` (local ONNX, today), future `JinaEmbedder`, + `OpenAiEmbedder`, etc. + - Stays pluggable forever -- no lock-in to fastembed or to nomic-embed-text. + +2. **`MemoryStore` trait** (new module `crates/vestige-core/src/storage/trait.rs`) + - One trait, ~25 methods across CRUD, search, FSRS, graph, domain sections. + - Uses `trait_variant::make` to generate a `Send`-bound variant for + `Arc` in Axum/tokio contexts. + - The 29 cognitive modules operate exclusively through this trait. No direct + SQLite or Postgres access from the modules. + +3. **`SqliteMemoryStore`** (refactor of existing `crates/vestige-core/src/storage/sqlite.rs`) + - Existing rusqlite + FTS5 + USearch code, wrapped behind the trait. + - Add `domains TEXT[]` equivalent (JSON-encoded array column in SQLite). + - Add `domain_scores` JSON column. + - No behavioral change for current users. + +4. **`PgMemoryStore`** (new `crates/vestige-core/src/storage/postgres.rs`) + - `sqlx::PgPool` with compile-time checked queries. + - pgvector HNSW index for vector search, tsvector + GIN for FTS. + - Native array columns for `domains`, JSONB for `domain_scores` and `metadata`. + - Hybrid search via RRF (Reciprocal Rank Fusion) in a single SQL query. + +5. **Model registry** + - Per-database table `embedding_model` with `(name, dimension, hash, created_at)`. + - Both backends refuse writes from an embedder whose signature doesn't match + the registered row. + - Model swap = `vestige migrate --reembed --model=`, O(n) cost, explicit. + +6. **`DomainClassifier` cognitive module** (new `crates/vestige-core/src/neuroscience/domain_classifier.rs`) + - Owns the HDBSCAN discovery pass (using the `hdbscan` crate). + - Computes soft-assignment scores for every memory against every centroid. + - Stores raw `domain_scores: HashMap` per memory; thresholds into + the `domains` array using `assign_threshold` (default 0.65). + - Runs discovery on demand (`vestige domains discover`) or during dream + consolidation passes. + +7. **HTTP MCP transport** (extension of existing Axum server in `crates/vestige-mcp/src/`) + - New route `POST /mcp` for Streamable HTTP JSON-RPC. + - New route `GET /mcp` for SSE (for long-running operations). + - REST API under `/api/v1/` for direct HTTP clients (non-MCP integrations). + - Auth middleware validates `Authorization: Bearer ...` or `X-API-Key`, plus + signed session cookies for dashboard. + +8. **Key management** (new `crates/vestige-mcp/src/auth/`) + - `api_keys` table -- blake3-hashed keys, scopes, optional domain filter, + last-used timestamp. + - CLI: `vestige keys create|list|revoke`. + +9. **FSRS review event log** (future-proofing for federation) + - New table `review_events` -- append-only `(memory_id, timestamp, rating, + prior_state, new_state)`. + - Current `scheduling` table becomes a materialized view over the event log + (reconstructible from events). + - Phase 5 federation merges event logs, not derived state. Zero cost today, + avoids lock-in tomorrow. + +### Data Flow + +**Local mode (stdio MCP, unchanged UX):** +``` +stdio client -> McpServer -> CognitiveEngine -> FastembedEmbedder -> MemoryStore (SQLite) +``` + +**Server mode (HTTP MCP, new):** +``` +Remote client -> Axum HTTP -> auth middleware -> CognitiveEngine + -> FastembedEmbedder (server-side) -> MemoryStore (Postgres) +``` + +The cognitive engine is backend-agnostic. The embedder and the store are both +swappable. The 7-stage search pipeline (overfetch -> cross-encoder rerank -> +temporal -> accessibility -> context match -> competition -> spreading activation) +sits *above* the `MemoryStore` trait and works identically against either backend. + +### Orthogonality of HDBSCAN and Reranking + +HDBSCAN and the cross-encoder reranker solve different problems and both stay: + +- **HDBSCAN** discovers domains by clustering embeddings. Runs once per discovery + pass. Produces centroids. Used to *filter* search candidates, not to rank them. +- **Cross-encoder reranker** (Jina Reranker v1 Turbo) scores query-document pairs + at search time. Runs on every search. Produces ranked results. + +Domain membership is a filter applied before or during overfetch; reranking runs +on whatever candidate set survives the filter. + +--- + +## Alternatives Considered + +| Alternative | Pros | Cons | Why Not | +|-------------|------|------|---------| +| Split into 4 traits (`MemoryStore + SchedulingStore + GraphStore + DomainStore`) | Cleaner interface segregation | Every module holds 4 trait objects, coordinates transactions across them | One trait is fine in Rust; extract sub-traits later if a genuine need appears | +| Embedding computed inside the backend | Simpler call sites for callers | Backend becomes aware of embedding models; can't support remote clients without local fastembed | Keep storage pure; separate `Embedder` trait handles pluggability | +| Unconstrained pgvector `vector` (no dimension) | Flexible for model swaps | HNSW still needs fixed dims at index creation; hides a meaningful migration as "silent" | Fixed dimension per install, explicit `--reembed` migration | +| Dashboard separate auth (cookies only, no keys) | Simpler dashboard UX | Two auth systems to maintain | Shared API keys with session cookie layer on top | +| Auto-tuned `assign_threshold` targeting an unclassified ratio | Adapts to corpus | Hard to debug ("why did this memory change domain?"); magical | Static 0.65 default, config-tunable, dashboard shows `domain_scores` for manual retuning | +| Aggressive drift (auto-reassign memories whose scores drifted) | Always up-to-date domains | Breaks user muscle memory; silent reshuffling | Conservative: always propose, user accepts | +| CRDTs for federation state | Mathematically clean merges | Massive complexity, performance cost, overkill | Defer; design FSRS as event log now so any future sync model works | + +--- + +## Consequences + +### Positive + +- Single memory brain accessible from every machine. +- Multi-agent concurrent access via Postgres MVCC. +- Natural topical scoping emerges from data, not manual tenants. +- Future embedding model swaps are a config + migration, not a rewrite. +- Federation has a clean on-ramp (event log merge) without committing now. +- The `Embedder` / `MemoryStore` split unlocks other storage backends later + (Redis, Qdrant, Iroh-backed blob store, etc.) with minimal work. + +### Negative + +- Operating a Postgres instance is more work than managing a SQLite file. +- Users who stay on SQLite gain nothing from this ADR (but lose nothing either). +- Migration (`vestige migrate --from sqlite --to postgres`) is a sensitive + operation for users with months of memories -- needs strong testing. +- HDBSCAN + re-soft-assignment runs in O(n) over all embeddings. At 100k+ + memories this starts to matter; manageable but not free. + +### Risks + +- **Trait abstraction leaks**: a cognitive module might need backend-specific + behavior (e.g., Postgres triggers for tsvector). Mitigation: keep such logic + inside the backend impl; the trait stays pure. + Escalation: if a module genuinely cannot express what it needs through the + trait, the trait grows, not the module bypasses. +- **Embedding model drift**: users on older fastembed versions silently + producing slightly different vectors after a fastembed upgrade. Mitigation: + model hash in the registry, refuse mismatched writes, surface a clear error. +- **Auth misconfiguration**: a user binds to `0.0.0.0` without setting + `auth.enabled = true`. Mitigation: refuse to start with non-localhost bind + and auth disabled. Hard error, not a warning. +- **Re-clustering feedback loop**: dream consolidation proposes re-clusters, + which the user accepts, which changes classifications, which affects future + retrievals, which affect future dreams. Mitigation: cap re-cluster frequency + (every 5th dream by default), require explicit user acceptance of proposals. +- **Cross-domain spreading activation weight (0.5 default)**: arbitrary choice; + could be too aggressive or too lax. Mitigation: config-tunable; instrument + retrieval quality metrics in the dashboard so the user sees impact. + +--- + +## Resolved Decisions (from Q&A) + +| # | Question | Resolution | +|---|----------|------------| +| 1 | Trait granularity | Single `MemoryStore` trait | +| 2 | Embedding on insert | Caller provides; separate `Embedder` trait for pluggability | +| 3 | pgvector dimension | Fixed per install, derived from `Embedder::dimension()` at schema init | +| 4 | Federation sync | Defer algorithm; store FSRS reviews as append-only event log now | +| 5 | Dashboard auth | Shared API keys + signed session cookie | +| 6 | HDBSCAN `min_cluster_size` | Default 10; user reruns with `--min-cluster-size N`; no auto-sweep | +| 7 | Domain drift | Conservative -- always propose splits/merges, never auto-apply | +| 8 | Cross-domain spreading activation | Follow with decay factor 0.5 (tunable) | +| 9 | Assignment threshold | Static 0.65 default, config-tunable, raw `domain_scores` stored for introspection | + +--- + +## Implementation Plan + +Five phases, each independently shippable. + +### Phase 1: Storage trait extraction +- Define `MemoryStore` and `Embedder` traits in `vestige-core`. +- Refactor `SqliteMemoryStore` to implement `MemoryStore`; no behavior change. +- Refactor `FastembedEmbedder` to implement `Embedder`. +- Add `embedding_model` registry table; enforce consistency on write. +- Add `domains TEXT[]`-equivalent and `domain_scores` JSON columns to SQLite + (empty for all existing rows). +- Convert all 29 cognitive modules to operate via the traits. +- **Acceptance**: existing test suite passes unchanged. Zero warnings. + +### Phase 2: PostgreSQL backend +- `PgMemoryStore` with sqlx, pgvector, tsvector. +- sqlx migrations (`crates/vestige-core/migrations/postgres/`). +- Backend selection via `vestige.toml` `[storage]` section. +- `vestige migrate --from sqlite --to postgres` command. +- `vestige migrate --reembed` command for model swaps. +- **Acceptance**: full test suite runs green against Postgres with a testcontainer. + +### Phase 3: Network access +- Streamable HTTP MCP route on Axum (`POST /mcp`, `GET /mcp` for SSE). +- REST API under `/api/v1/`. +- API key table + blake3 hashing + `vestige keys create|list|revoke`. +- Auth middleware (Bearer, X-API-Key, session cookie). +- Refuse non-localhost bind without auth enabled. +- **Acceptance**: MCP client over HTTP works from a second machine; dashboard + login flow works; unauth requests return 401. + +### Phase 4: Emergent domain classification +- `DomainClassifier` module using the `hdbscan` crate. +- `vestige domains discover|list|rename|merge` CLI. +- Automatic soft-assignment pipeline (compute `domain_scores` on ingest, threshold + into `domains`). +- Re-cluster every Nth dream consolidation (default 5); surface proposals in the + dashboard. +- Context signals (git repo, IDE) as soft priors on classification. +- Cross-domain spreading activation with 0.5 decay. +- **Acceptance**: on a corpus of 500+ mixed memories, discover produces sensible + clusters; search scoped to a domain returns tightly relevant results. + +### Phase 5: Federation (future, explicitly out of scope for this ADR's +acceptance) +- Node discovery (Mycelium / mDNS). +- Memory sync protocol over append-only review events and LWW-per-UUID for + memory records. +- Explicit follow-up ADR before any code. + +--- + +## Open Questions + +None at ADR acceptance time. Follow-up items that are *implementation choices*, +not architectural: + +- Precise cross-domain decay weight (start at 0.5, instrument, tune) +- Dashboard histogram of `domain_scores` (UX design detail) +- Whether to gate Postgres behind a Cargo feature flag (`postgres-backend`) or + always compile it in (lean toward feature flag to keep SQLite-only builds small) diff --git a/docs/plans/0001-phase-1-storage-trait-extraction.md b/docs/plans/0001-phase-1-storage-trait-extraction.md new file mode 100644 index 0000000..9960462 --- /dev/null +++ b/docs/plans/0001-phase-1-storage-trait-extraction.md @@ -0,0 +1,1026 @@ +# Phase 1 Plan: Storage Trait Extraction + +**Status**: Draft +**Depends on**: none +**Related**: docs/adr/0001-pluggable-storage-and-network-access.md (Phase 1) + +--- + +## Scope + +### In scope + +- Introduce a new module `crates/vestige-core/src/storage/memory_store.rs` defining: + - `LocalMemoryStore` base trait (Sync + 'static) + - `MemoryStore` Send-bound alias generated via `#[trait_variant::make(MemoryStore: Send)]` + - Supporting data types referenced by the trait: `MemoryRecord`, `SchedulingState`, `SearchQuery`, `SearchResult`, `MemoryEdge`, `Domain`, `ClassificationResult`, `StoreStats`, `HealthStatus`, `MemoryStoreError`. +- Introduce a new module `crates/vestige-core/src/embedder/` defining: + - `Embedder` async trait with `embed`, `model_name`, `dimension` plus `model_hash` (for the registry) and optional `embed_batch` with a default implementation. + - Move/adapt the existing `EmbeddingService` impl into a new struct `FastembedEmbedder` that implements `Embedder`. +- Refactor `Storage` (existing `crates/vestige-core/src/storage/sqlite.rs`) into `SqliteMemoryStore`: + - Keep the struct, the `writer`/`reader` `Mutex` pair, the `FSRSScheduler`, and the USearch `VectorIndex`. + - Rename the type alias `Storage` to `SqliteMemoryStore` with a `pub type Storage = SqliteMemoryStore;` alias for backward source compatibility during the transition. (The trait method surface is the new public contract.) + - Implement `LocalMemoryStore` by wrapping existing synchronous `rusqlite` methods inside `async fn` bodies that call a small `spawn_blocking`-or-inline adapter. Bodies MAY block; the `async fn` signature exists because `LocalMemoryStore` is async. +- Add a `schema_version = 12` migration that introduces two schema additions: + 1. `embedding_model` registry table (one-row constraint enforced in code). + 2. Two new TEXT columns on `knowledge_nodes`: `domains TEXT NOT NULL DEFAULT '[]'` and `domain_scores TEXT NOT NULL DEFAULT '{}'` (both JSON-encoded). +- Enforce model registry on every write path: on the first non-empty embedding write the model signature is recorded; subsequent writes whose `Embedder::model_name()` / `dimension()` / `model_hash()` disagree must fail with `MemoryStoreError::ModelMismatch` before touching the DB. +- Audit all 29 cognitive modules under `crates/vestige-core/src/neuroscience/` and `crates/vestige-core/src/advanced/` to confirm they hold no direct `rusqlite::Connection` references, no `Storage` struct field, and no SQL strings. Any that do get refactored to take `&dyn LocalMemoryStore` (local-only modules) or `&Arc` (modules crossing `await` points). +- Add unit tests alongside each new trait method and integration tests in `tests/phase_1/`. + +### Out of scope + +- Implementing `PgMemoryStore` on sqlx + pgvector -- that is Phase 2. +- `vestige migrate --from sqlite --to postgres` and `vestige migrate --reembed` -- Phase 2. +- MCP over Streamable HTTP, API key middleware, `api_keys` table, `vestige keys create|list|revoke` -- Phase 3. +- `DomainClassifier` module, HDBSCAN clustering, `vestige domains discover|list|rename|merge` CLI, incremental soft-assignment, cross-domain spreading activation decay -- Phase 4. +- Federation, mycelium/mDNS node discovery, review event log table -- Phase 5. +- Removing the `pub type Storage = SqliteMemoryStore;` compatibility alias -- that cleanup happens at the end of Phase 4 when no consumers still spell the old name. + +## Prerequisites + +### Current code state + +- Single concrete type `Storage` in `crates/vestige-core/src/storage/sqlite.rs` (4592 lines, 216 public symbols on the impl blocks, approximately 85 public methods) is the only storage surface the crate exposes. +- `EmbeddingService` in `crates/vestige-core/src/embeddings/local.rs` holds the fastembed singleton. No trait exists; callers type-erase via `&EmbeddingService`. +- Migrations live in `crates/vestige-core/src/storage/migrations.rs`; the current head is v11. +- All cognitive modules in `neuroscience/` and `advanced/` are pure (verified by `grep rusqlite|Connection::|execute\(|prepare\(` returning no matches in those trees). They operate on `KnowledgeNode`, `Vec`, `ConnectionRecord`, etc. passed in by the caller. +- `vestige-mcp` consumes `Arc` in `crates/vestige-mcp/src/server.rs` and every tool under `crates/vestige-mcp/src/tools/`. These call sites will type-check unchanged after the alias is introduced because the trait methods preserve the exact signatures of the existing `pub fn` on `Storage`. +- Test count reported in `CLAUDE.md`: 758 tests (406 mcp + 352 core). This is the no-regression target. + +### Required crates (add via `cargo add` under `crates/vestige-core`) + +| Crate | Version | Why | +|-------|---------|-----| +| `trait-variant` | `0.1` | Generates the `Send`-bound `MemoryStore` alias from `LocalMemoryStore` so `Arc` works under tokio/axum without hand-writing two traits. Listed in PRD section "Crate Dependencies (new)" under Phase 1. | +| `blake3` | `1` | `Embedder::model_hash() -> [u8; 32]` uses blake3 to stabilise the "model signature" stored in the `embedding_model` registry. Already slated for Phase 3 auth; pulling it forward costs nothing and avoids a second migration to add a hash column. | +| `async-trait` | `0.1` | Not strictly required with `trait-variant` on MSRV 1.91 (RPITIT is stable), but used for one utility trait (`EmbedderExt`) that carries a default `embed_batch` body. OPTIONAL; see Open Implementation Questions below. | + +No changes to `vestige-mcp/Cargo.toml` are required for Phase 1 -- the new trait lives in `vestige-core` and the mcp crate continues to depend on the `SqliteMemoryStore` concrete type (via the `Storage` alias) until Phase 2 introduces backend selection. + +## Deliverables + +1. `crates/vestige-core/src/storage/memory_store.rs` -- `LocalMemoryStore` + `MemoryStore` traits and supporting types. +2. `crates/vestige-core/src/storage/mod.rs` -- updated exports and module wiring. +3. `crates/vestige-core/src/storage/sqlite.rs` -- `Storage` renamed to `SqliteMemoryStore`, `impl LocalMemoryStore for SqliteMemoryStore` block, enforcement hooks for the model registry, serde of `domains` / `domain_scores` columns. +4. `crates/vestige-core/src/storage/migrations.rs` -- `MIGRATION_V12_UP` adding `embedding_model` table and `domains`, `domain_scores` columns. +5. `crates/vestige-core/src/embedder/mod.rs` -- `Embedder` trait and re-exports. +6. `crates/vestige-core/src/embedder/fastembed.rs` -- `FastembedEmbedder` implementation. +7. `crates/vestige-core/src/embeddings/local.rs` -- retained; `EmbeddingService` kept as the underlying fastembed holder; `FastembedEmbedder` wraps it. +8. `crates/vestige-core/src/lib.rs` -- new `pub mod embedder;` + re-exports for `MemoryStore`, `LocalMemoryStore`, `Embedder`, `FastembedEmbedder`, and the data types. +9. `tests/phase_1/trait_round_trip.rs` -- integration test: round-trip of every trait method through `SqliteMemoryStore`. +10. `tests/phase_1/embedding_model_registry.rs` -- integration test: first-write registers, mismatch refuses, dimension mismatch refuses. +11. `tests/phase_1/domain_column_migration.rs` -- integration test: a v11 DB upgraded to v12 reads `domains=[]` and `domain_scores={}` for all existing rows. +12. `tests/phase_1/cognitive_module_isolation.rs` -- integration test: every cognitive module compiles and executes against an `Arc` without touching `SqliteMemoryStore` concretely. +13. `tests/phase_1/send_bound_variant.rs` -- integration test: an `Arc` can be moved across `tokio::spawn`. +14. Updated `tests/phase_1/mod.rs` (if the dir already uses a module layout) or individual `[[test]]` entries in `tests/e2e/Cargo.toml` as needed -- see "Test Plan" for the exact layout. + +## Detailed Task Breakdown + +### D1. Trait + supporting types (`memory_store.rs`) + +- **File**: `crates/vestige-core/src/storage/memory_store.rs` (new). +- **Depends on**: `trait-variant` crate added under vestige-core, `chrono`, `serde_json`, `uuid`, `thiserror` (all already in Cargo.toml). +- **Signatures**: + +```rust +//! Backend-agnostic memory store trait. +//! +//! This is the single abstraction every cognitive module sits above. It is +//! intentionally flat: one trait, ~25 methods, no sub-traits. + +use std::collections::HashMap; + +use chrono::{DateTime, Utc}; +use serde::{Deserialize, Serialize}; +use uuid::Uuid; + +// ---------------------------------------------------------------------------- +// ERROR +// ---------------------------------------------------------------------------- + +/// Error returned by every `LocalMemoryStore` / `MemoryStore` method. +#[non_exhaustive] +#[derive(Debug, thiserror::Error)] +pub enum MemoryStoreError { + #[error("not found: {0}")] + NotFound(String), + + #[error("backend error: {0}")] + Backend(String), + + #[error( + "embedding model mismatch: store registered {registered_name} (dim {registered_dim}, \ + hash {registered_hash}), embedder is {actual_name} (dim {actual_dim}, hash {actual_hash})" + )] + ModelMismatch { + registered_name: String, + registered_dim: usize, + registered_hash: String, + actual_name: String, + actual_dim: usize, + actual_hash: String, + }, + + #[error("invalid input: {0}")] + InvalidInput(String), + + #[error("initialization error: {0}")] + Init(String), +} + +impl From for MemoryStoreError { + fn from(e: crate::storage::StorageError) -> Self { + use crate::storage::StorageError as S; + match e { + S::NotFound(s) => MemoryStoreError::NotFound(s), + S::Database(e) => MemoryStoreError::Backend(e.to_string()), + S::Io(e) => MemoryStoreError::Backend(e.to_string()), + S::InvalidTimestamp(s) => MemoryStoreError::Backend(format!("invalid timestamp: {s}")), + S::Init(s) => MemoryStoreError::Init(s), + } + } +} + +pub type MemoryStoreResult = std::result::Result; + +// ---------------------------------------------------------------------------- +// DATA TYPES +// ---------------------------------------------------------------------------- + +/// Backend-agnostic memory record. +/// +/// Phase 1 intentionally keeps this type independent of `KnowledgeNode` to +/// avoid dragging 30+ legacy fields through the trait surface. The SQLite +/// backend converts between `MemoryRecord` and `KnowledgeNode` at the +/// boundary. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct MemoryRecord { + pub id: Uuid, + /// Empty = unclassified. Populated in Phase 4. + pub domains: Vec, + /// Raw similarity per domain centroid. Empty until Phase 4 runs clustering. + pub domain_scores: HashMap, + pub content: String, + pub node_type: String, + pub tags: Vec, + pub embedding: Option>, + pub created_at: DateTime, + pub updated_at: DateTime, + pub metadata: serde_json::Value, +} + +/// FSRS-6 scheduling state, one row per memory. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SchedulingState { + pub memory_id: Uuid, + pub stability: f64, + pub difficulty: f64, + pub retrievability: f64, + pub last_review: Option>, + pub next_review: Option>, + pub reps: u32, + pub lapses: u32, +} + +/// Hybrid search request. +#[derive(Debug, Clone, Default)] +pub struct SearchQuery { + pub domains: Option>, + pub text: Option, + pub embedding: Option>, + pub tags: Option>, + pub node_types: Option>, + pub limit: usize, + pub min_retrievability: Option, +} + +#[derive(Debug, Clone)] +pub struct SearchResult { + pub record: MemoryRecord, + pub score: f64, + pub fts_score: Option, + pub vector_score: Option, +} + +/// Edge in the spreading-activation graph. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct MemoryEdge { + pub source_id: Uuid, + pub target_id: Uuid, + pub edge_type: String, + pub weight: f64, + pub created_at: DateTime, +} + +/// A topical domain (populated in Phase 4). Phase 1 only needs the type to +/// shape the trait surface; discover/classify are Phase 4 work. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct Domain { + pub id: String, + pub label: String, + pub centroid: Vec, + pub top_terms: Vec, + pub memory_count: usize, + pub created_at: DateTime, +} + +/// Result of classifying one vector against all known domains. +#[derive(Debug, Clone)] +pub struct ClassificationResult { + pub scores: HashMap, + pub domains: Vec, +} + +#[derive(Debug, Clone, Serialize, Deserialize, Default)] +pub struct StoreStats { + pub total_memories: usize, + pub memories_with_embeddings: usize, + pub total_edges: usize, + pub total_domains: usize, + pub registered_model_name: Option, + pub registered_model_dim: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum HealthStatus { + Healthy, + Degraded { reason: String }, + Unavailable { reason: String }, +} + +// ---------------------------------------------------------------------------- +// EMBEDDING MODEL SIGNATURE +// ---------------------------------------------------------------------------- + +/// Snapshot of the embedding model that was used to write vectors into the +/// store. Persisted in the `embedding_model` table; compared on every write +/// before the vector is accepted. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct ModelSignature { + pub name: String, + pub dimension: usize, + /// Lowercase hex-encoded blake3 hash, 64 chars. + pub hash: String, +} + +// ---------------------------------------------------------------------------- +// TRAIT +// ---------------------------------------------------------------------------- + +/// The single storage abstraction. `trait_variant::make` auto-generates a +/// `MemoryStore` alias with `Send`-bound return futures so `Arc` +/// works in tokio/axum contexts. +#[trait_variant::make(MemoryStore: Send)] +pub trait LocalMemoryStore: Sync + 'static { + // --- Lifecycle --- + async fn init(&self) -> MemoryStoreResult<()>; + async fn health_check(&self) -> MemoryStoreResult; + + // --- Embedding model registry --- + async fn registered_model(&self) -> MemoryStoreResult>; + async fn register_model(&self, sig: &ModelSignature) -> MemoryStoreResult<()>; + + // --- CRUD --- + async fn insert(&self, record: &MemoryRecord) -> MemoryStoreResult; + async fn get(&self, id: Uuid) -> MemoryStoreResult>; + async fn update(&self, record: &MemoryRecord) -> MemoryStoreResult<()>; + async fn delete(&self, id: Uuid) -> MemoryStoreResult<()>; + + // --- Search --- + async fn search(&self, query: &SearchQuery) -> MemoryStoreResult>; + async fn fts_search(&self, text: &str, limit: usize) -> MemoryStoreResult>; + async fn vector_search( + &self, + embedding: &[f32], + limit: usize, + ) -> MemoryStoreResult>; + + // --- FSRS Scheduling --- + async fn get_scheduling( + &self, + memory_id: Uuid, + ) -> MemoryStoreResult>; + async fn update_scheduling(&self, state: &SchedulingState) -> MemoryStoreResult<()>; + async fn get_due_memories( + &self, + before: DateTime, + limit: usize, + ) -> MemoryStoreResult>; + + // --- Graph (spreading activation) --- + async fn add_edge(&self, edge: &MemoryEdge) -> MemoryStoreResult<()>; + async fn get_edges( + &self, + node_id: Uuid, + edge_type: Option<&str>, + ) -> MemoryStoreResult>; + async fn remove_edge(&self, source: Uuid, target: Uuid) -> MemoryStoreResult<()>; + async fn get_neighbors( + &self, + node_id: Uuid, + depth: usize, + ) -> MemoryStoreResult>; + + // --- Domains (Phase 1: stubs return empty; full impl in Phase 4) --- + async fn list_domains(&self) -> MemoryStoreResult>; + async fn get_domain(&self, id: &str) -> MemoryStoreResult>; + async fn upsert_domain(&self, domain: &Domain) -> MemoryStoreResult<()>; + async fn delete_domain(&self, id: &str) -> MemoryStoreResult<()>; + /// Phase 1: returns `Ok(vec![])` since no centroids exist. Phase 4 wires + /// the full soft-assignment pass. + async fn classify(&self, embedding: &[f32]) -> MemoryStoreResult>; + + // --- Bulk / Maintenance --- + async fn count(&self) -> MemoryStoreResult; + async fn get_stats(&self) -> MemoryStoreResult; + async fn vacuum(&self) -> MemoryStoreResult<()>; +} +``` + +- **Behavior notes**: + - Every method returns `MemoryStoreResult`; the trait never exposes `rusqlite::Error`. + - `LocalMemoryStore` requires `Sync + 'static` so `Arc` is usable. The auto-generated `MemoryStore` alias adds `Send` bounds on the returned `impl Future`. + - `register_model` is idempotent: writing the same signature twice is `Ok(())`. Writing a different signature after one is registered returns `MemoryStoreError::ModelMismatch`. + - `classify` on Phase 1 returns `Ok(vec![])` and MUST NOT error; cognitive modules call it and Phase 4 will flesh it out without changing the signature. + - `upsert_domain` / `delete_domain` / `list_domains` / `get_domain` operate against a `domains` table that is empty until Phase 4 populates it. Phase 1 still exposes the methods so Phase 2 can implement them against Postgres in one shot. + - `get_neighbors(node_id, depth)` with `depth == 0` returns just `(node, 1.0)` if the node exists, otherwise `NotFound`. `depth > 0` performs breadth-first expansion over edges, weight = product of edge weights along the shortest path discovered, capped at `max_neighbors = 256` to prevent runaway expansion. + +--- + +### D2. Storage module wiring (`storage/mod.rs`) + +- **File**: `crates/vestige-core/src/storage/mod.rs`. +- **Depends on**: D1. +- **Signatures / diff**: + +```rust +//! Storage Module +//! +//! Backend-agnostic memory store abstraction plus SQLite reference impl. + +mod memory_store; +mod migrations; +mod sqlite; + +pub use memory_store::{ + ClassificationResult, Domain, HealthStatus, LocalMemoryStore, MemoryEdge, MemoryRecord, + MemoryStore, MemoryStoreError, MemoryStoreResult, ModelSignature, SchedulingState, + SearchQuery, SearchResult, StoreStats, +}; +pub use migrations::MIGRATIONS; +pub use sqlite::{ + ConnectionRecord, ConsolidationHistoryRecord, DreamHistoryRecord, InsightRecord, + IntentionRecord, Result, SmartIngestResult, SqliteMemoryStore, StateTransitionRecord, + StorageError, +}; + +/// Backwards-compatibility alias. Retained until Phase 4 completes so every +/// existing `Arc` call site keeps compiling. Scheduled for removal +/// once no downstream source file references it. +pub type Storage = SqliteMemoryStore; +``` + +- **Behavior notes**: + - The alias MUST be a `pub type` (not a re-export), because several tool files pattern on `vestige_core::Storage` through `use` statements and we want to keep them compiling verbatim. This has zero runtime cost. + - `StorageError` stays exported for the 29 existing inherent-method callers; the trait exposes `MemoryStoreError` and provides `From`. + +--- + +### D3. Rename + trait impl in `sqlite.rs` + +- **File**: `crates/vestige-core/src/storage/sqlite.rs`. +- **Depends on**: D1, D2, D4 (for schema columns), D5/D6 (to have `Embedder` to accept on `insert`). +- **Signatures (key excerpts)**: + +```rust +pub struct SqliteMemoryStore { + writer: Mutex, + reader: Mutex, + scheduler: Mutex, + #[cfg(feature = "embeddings")] + embedding_service: EmbeddingService, + #[cfg(feature = "vector-search")] + vector_index: Mutex, + #[cfg(feature = "embeddings")] + query_cache: Mutex>>, + /// Cached model signature. `None` until the first embedding is written. + registered_model: std::sync::RwLock>, +} + +impl SqliteMemoryStore { + pub fn new(db_path: Option) -> MemoryStoreResult { /* existing body, Result converted */ } + + /// Internal: convert a row into a `MemoryRecord` (new mapping reading + /// `domains` / `domain_scores` JSON columns). + fn row_to_record(row: &rusqlite::Row) -> rusqlite::Result { /* ... */ } + + /// Internal: given a `MemoryRecord` plus an optional embedding, enforce + /// the registered model signature and return a `MemoryStoreError` if + /// the embedder would produce a mismatched vector. + fn enforce_model( + &self, + incoming: Option<&ModelSignature>, + ) -> MemoryStoreResult<()> { /* ... */ } +} + +impl crate::storage::memory_store::LocalMemoryStore for SqliteMemoryStore { + async fn init(&self) -> MemoryStoreResult<()> { /* no-op; migrations run in `new` */ Ok(()) } + + async fn health_check(&self) -> MemoryStoreResult { + // SELECT 1; check vector index loaded; check embedding_model presence. + } + + async fn registered_model(&self) -> MemoryStoreResult> { + let cached = self.registered_model.read().map_err(|_| MemoryStoreError::Init("registered_model rwlock poisoned".into()))?.clone(); + if cached.is_some() { + return Ok(cached); + } + // Fall through to DB read... + } + + async fn register_model(&self, sig: &ModelSignature) -> MemoryStoreResult<()> { + // INSERT OR IGNORE; if a row exists and differs, return ModelMismatch. + } + + async fn insert(&self, record: &MemoryRecord) -> MemoryStoreResult { + if let Some(vec) = &record.embedding { + // Caller is REQUIRED to have called register_model first (or the + // store auto-registers on the first embedded write -- see + // "embedding_model_registry.rs" test). + let derived = ModelSignature { /* from cache or from record.metadata */ }; + self.enforce_model(Some(&derived))?; + if vec.len() != derived.dimension { + return Err(MemoryStoreError::InvalidInput( + format!("embedding length {} != registered dimension {}", vec.len(), derived.dimension), + )); + } + } + // Delegate to a private `insert_record_blocking` helper that is the + // current `ingest`/`update_node_content` body, rewritten to accept a + // `MemoryRecord` and to also write `domains` / `domain_scores` JSON. + } + + // ... remaining ~24 methods follow the same pattern: convert inputs, + // call the existing synchronous body, convert outputs. +} +``` + +- **SQL** (covered in full in D4 below). +- **Behavior notes**: + - The `async fn` bodies are allowed to be synchronous under the hood (rusqlite is blocking). We do NOT wrap in `spawn_blocking` for Phase 1 -- the current `Storage` is already used from synchronous code paths (CLI, MCP stdio handler) and forcing the tokio runtime is a Phase 2 concern when we also add sqlx. The trait simply lifts the synchronous body into an `async fn` so the signatures match the trait. MSRV 1.91 supports async fn in trait via `trait_variant::make`. + - `insert` preserves the current FSRS initialization logic (stability, difficulty, next_review, etc.) -- the new code path converts `MemoryRecord.metadata` back into `IngestInput`-equivalent fields when needed. All existing inherent methods (`ingest`, `smart_ingest`, `mark_reviewed`, ...) remain on `SqliteMemoryStore` untouched; the trait impl calls into them. + - `registered_model` cache is an `RwLock>`. Invalidated on schema reset. Never mutated after first population until an explicit `--reembed` migration (Phase 2) takes the RwLock exclusively and writes a new row. + - `enforce_model` returns `Ok(())` if no model is registered yet AND `incoming.is_none()` (no-embedding write). Returns `Ok(())` if no model is registered and `incoming.is_some()` after calling `register_model`. Returns `Err(ModelMismatch)` if registered and they disagree. + - `domains` / `domain_scores` serialization uses `serde_json::to_string` on write and `serde_json::from_str` on read. Empty vec -> `"[]"`, empty map -> `"{}"`. `NULL` in the DB is treated as the empty value for pre-migration rows. + - Every existing inherent method is kept verbatim. The trait impl dispatches to them. This is the "no behavior change" guarantee. + +--- + +### D4. Schema migration V12 + +- **File**: `crates/vestige-core/src/storage/migrations.rs`. +- **Depends on**: D2. +- **SQL**: + +```sql +-- Migration V12: embedding model registry + per-memory domain columns. + +-- 1. Embedding model registry. Single logical row; the (id = 1) constraint is +-- enforced in code via `register_model` (SQLite CHECK on a single-row +-- table is uglier than a constraint we already enforce in Rust). +CREATE TABLE IF NOT EXISTS embedding_model ( + id INTEGER PRIMARY KEY CHECK (id = 1), + name TEXT NOT NULL, + dimension INTEGER NOT NULL, + hash TEXT NOT NULL, -- lowercase hex blake3 + created_at TEXT NOT NULL +); + +-- 2. Per-memory domain columns (JSON TEXT; SQLite has no native arrays). +ALTER TABLE knowledge_nodes ADD COLUMN domains TEXT NOT NULL DEFAULT '[]'; +ALTER TABLE knowledge_nodes ADD COLUMN domain_scores TEXT NOT NULL DEFAULT '{}'; + +-- 3. Index on the domains JSON column to enable `LIKE '%"dev"%'`-style +-- filter in Phase 4. Kept lightweight here; Postgres will use GIN. +CREATE INDEX IF NOT EXISTS idx_nodes_domains ON knowledge_nodes(domains); +CREATE INDEX IF NOT EXISTS idx_nodes_domain_scores ON knowledge_nodes(domain_scores); + +-- 4. Domains catalogue (empty until Phase 4 populates). +CREATE TABLE IF NOT EXISTS domains ( + id TEXT PRIMARY KEY, + label TEXT NOT NULL, + centroid BLOB, -- f32 vector, raw bytes + top_terms TEXT NOT NULL DEFAULT '[]', + memory_count INTEGER NOT NULL DEFAULT 0, + created_at TEXT NOT NULL +); + +CREATE INDEX IF NOT EXISTS idx_domains_created_at ON domains(created_at); + +UPDATE schema_version SET version = 12, applied_at = datetime('now'); +``` + +- **Rust changes** to `migrations.rs`: + +```rust +pub const MIGRATIONS: &[Migration] = &[ + // ... V1..V11 unchanged ... + Migration { + version: 12, + description: "Phase 1: embedding_model registry, domains/domain_scores columns, domains table", + up: MIGRATION_V12_UP, + }, +]; + +const MIGRATION_V12_UP: &str = r#"...SQL above..."#; +``` + +- **Behavior notes**: + - Idempotent: `ALTER TABLE ... ADD COLUMN` on SQLite is not idempotent by default, but the `apply_migrations` driver only applies migrations whose version > current. A user who has already applied V12 never sees the SQL again. + - The `CHECK (id = 1)` on `embedding_model` is the only one-row guardrail -- all inserts go through `register_model` which uses `INSERT OR IGNORE INTO embedding_model (id, ...) VALUES (1, ...)` followed by a `SELECT` to detect mismatch. + - `centroid BLOB` stores the f32 vector using the same `Embedding::to_bytes()` format used in `node_embeddings`, for consistency. + +--- + +### D5. Embedder trait (`embedder/mod.rs`) + +- **File**: `crates/vestige-core/src/embedder/mod.rs` (new). +- **Depends on**: `blake3` crate added to vestige-core. +- **Signatures**: + +```rust +//! Text-to-vector encoding trait. Pluggable per-install. + +use std::fmt::Debug; + +mod fastembed; + +pub use fastembed::FastembedEmbedder; + +/// Error returned by every `Embedder` method. +#[non_exhaustive] +#[derive(Debug, thiserror::Error)] +pub enum EmbedderError { + #[error("embedder initialization failed: {0}")] + Init(String), + #[error("embedding generation failed: {0}")] + EmbedFailed(String), + #[error("invalid input: {0}")] + InvalidInput(String), +} + +pub type EmbedderResult = std::result::Result; + +/// Pluggable embedder. The storage layer NEVER calls fastembed directly; +/// callers compute vectors via this trait and pass them into `MemoryStore`. +#[trait_variant::make(Embedder: Send)] +pub trait LocalEmbedder: Sync + 'static { + async fn embed(&self, text: &str) -> EmbedderResult>; + + fn model_name(&self) -> &str; + + fn dimension(&self) -> usize; + + /// Stable blake3 hash of (model_name || dimension || optional weights + /// digest if available). Lowercase hex, 64 chars. + /// + /// Used by `MemoryStore::register_model` to detect silent model drift + /// (e.g. a fastembed minor upgrade that changes vector output). + fn model_hash(&self) -> String; + + async fn embed_batch(&self, texts: &[&str]) -> EmbedderResult>> { + // Default: sequential. Backends with native batching override this. + let mut out = Vec::with_capacity(texts.len()); + for t in texts { + out.push(self.embed(t).await?); + } + Ok(out) + } + + /// Returns the `ModelSignature` describing this embedder. Convenience + /// wrapper over the three accessors above. + fn signature(&self) -> crate::storage::ModelSignature { + crate::storage::ModelSignature { + name: self.model_name().to_string(), + dimension: self.dimension(), + hash: self.model_hash(), + } + } +} +``` + +- **Behavior notes**: + - The `embed_batch` default implementation is non-trivial only in that backends with genuine batching override it. The `FastembedEmbedder` overrides to call `EmbeddingService::embed_batch`. + - `model_hash()` is intentionally a function, not a constant, so backends with configurable weights (a future `OnnxEmbedder` that loads an arbitrary file) can hash the file bytes into the signature. + - `Embedder` (the `Send` variant) is what cognitive modules bind against when they hold `Arc`. `LocalEmbedder` is available for single-threaded callers (CLI, tests). + +--- + +### D6. FastembedEmbedder impl (`embedder/fastembed.rs`) + +- **File**: `crates/vestige-core/src/embedder/fastembed.rs` (new). +- **Depends on**: D5, existing `crate::embeddings::local::EmbeddingService`. +- **Signatures**: + +```rust +use super::{EmbedderError, EmbedderResult, LocalEmbedder}; +use crate::embeddings::{EMBEDDING_DIMENSIONS, EmbeddingService, matryoshka_truncate}; + +pub struct FastembedEmbedder { + inner: EmbeddingService, + cached_hash: std::sync::OnceLock, +} + +impl FastembedEmbedder { + pub fn new() -> Self { + Self { + inner: EmbeddingService::new(), + cached_hash: std::sync::OnceLock::new(), + } + } + + fn compute_hash(name: &str, dim: usize) -> String { + let mut hasher = blake3::Hasher::new(); + hasher.update(name.as_bytes()); + hasher.update(&(dim as u64).to_le_bytes()); + // fastembed's ONNX bytes are not directly accessible at runtime; we + // use `(name, dim, static fastembed crate version)` as the + // signature. If fastembed ever changes its output deterministically + // between minor versions, bumping the crate version triggers a + // mismatch -- which is exactly the drift we want to detect. + hasher.update(env!("CARGO_PKG_VERSION").as_bytes()); + hasher.finalize().to_hex().to_string() + } +} + +impl Default for FastembedEmbedder { + fn default() -> Self { Self::new() } +} + +impl LocalEmbedder for FastembedEmbedder { + async fn embed(&self, text: &str) -> EmbedderResult> { + let emb = self + .inner + .embed(text) + .map_err(|e| EmbedderError::EmbedFailed(e.to_string()))?; + Ok(emb.vector) + } + + fn model_name(&self) -> &str { self.inner.model_name() } + + fn dimension(&self) -> usize { EMBEDDING_DIMENSIONS } + + fn model_hash(&self) -> String { + self.cached_hash + .get_or_init(|| Self::compute_hash(self.inner.model_name(), EMBEDDING_DIMENSIONS)) + .clone() + } + + async fn embed_batch(&self, texts: &[&str]) -> EmbedderResult>> { + let embs = self + .inner + .embed_batch(texts) + .map_err(|e| EmbedderError::EmbedFailed(e.to_string()))?; + Ok(embs.into_iter().map(|e| e.vector).collect()) + } +} +``` + +- **Behavior notes**: + - `EmbeddingService` is kept as the fastembed singleton holder; `FastembedEmbedder` is a thin trait adapter. Existing callers of `EmbeddingService` continue to work during the transition. + - `model_hash` is deterministic for a given `(model_name, EMBEDDING_DIMENSIONS, vestige-core version)` triple. This is the drift detector the ADR calls out under "Risks: Embedding model drift". + - `matryoshka_truncate` is already applied inside `EmbeddingService::embed`, so the vectors returned here are the 256-dim Matryoshka-truncated L2-normalized vectors that the rest of the stack expects. + +--- + +### D7. `lib.rs` re-exports + +- **File**: `crates/vestige-core/src/lib.rs`. +- **Depends on**: D1, D2, D5, D6. +- **Diff** (inserted alongside the existing `pub mod storage;` re-exports): + +```rust +pub mod embedder; + +pub use embedder::{Embedder, EmbedderError, EmbedderResult, FastembedEmbedder, LocalEmbedder}; + +pub use storage::{ + ClassificationResult, Domain, HealthStatus, LocalMemoryStore, MemoryEdge, MemoryRecord, + MemoryStore, MemoryStoreError, MemoryStoreResult, ModelSignature, SchedulingState, + SearchQuery, SearchResult, SqliteMemoryStore, Storage, StoreStats, + // Existing re-exports retained: + ConnectionRecord, ConsolidationHistoryRecord, DreamHistoryRecord, InsightRecord, + IntentionRecord, Result, SmartIngestResult, StateTransitionRecord, StorageError, +}; +``` + +- **Behavior notes**: + - `Storage` remains a top-level re-export so `use vestige_core::Storage;` keeps working in `vestige-mcp` without changes. Post-Phase-4 cleanup will grep the downstream crates and replace. + +--- + +### D8. Cognitive module audit + +- **Files**: all under `crates/vestige-core/src/neuroscience/*.rs` and `crates/vestige-core/src/advanced/*.rs` -- 21 source files. +- **Depends on**: D1..D7. +- **Work**: perform the following grep-gate BEFORE and AFTER the refactor: + +``` +Grep pattern: "rusqlite|Connection::|execute\\(|prepare\\(|&Storage|SqliteMemoryStore" +Expected in neuroscience/ and advanced/ BEFORE: only a single comment-only hit in `neuroscience/active_forgetting.rs:54` referencing `Storage::suppress_memory` in a doc comment. +Expected AFTER: zero hits that reference `SqliteMemoryStore` concretely. References through `&dyn LocalMemoryStore` or `&Arc` are acceptable. +``` + +- **Behavior notes**: + - Current state: the 29 cognitive modules are already pure (they take nodes/vectors/connections as arguments, not a `&Storage`). No refactor is required for their bodies. + - The only work is the `consolidation/sleep.rs` and `consolidation/phases.rs` path, which in the current codebase accepts `&Storage`. These get rewritten to accept `&dyn LocalMemoryStore` (callable from sync contexts) or `&Arc` (callable from async contexts). See file inventory below. + - Actual rewrites (expected number): 3-5 functions across `consolidation/sleep.rs` and `consolidation/mod.rs`. All trait-object refactors; no logic changes. + - `cognitive.rs` in `vestige-mcp` uses `storage.get_all_connections()`. Because `SqliteMemoryStore` keeps `get_all_connections` as an inherent method AND implements `MemoryStore::get_edges`, both call styles keep compiling. `cognitive.rs` does not need to change in Phase 1. + +--- + +### D9. Backwards-compatible inherent methods on `SqliteMemoryStore` + +- **File**: `crates/vestige-core/src/storage/sqlite.rs`. +- **Depends on**: D3. +- **Behavior notes**: + - Every one of the 85 existing `pub fn` on `Storage` (e.g. `ingest`, `smart_ingest`, `mark_reviewed`, `hybrid_search_filtered`, `save_intention`, `save_insight`, `save_connection`, `apply_rac1_cascade`, ...) stays as an inherent method on `SqliteMemoryStore`. The Phase 1 refactor ONLY adds the trait impl; it does NOT remove any method, rename any field, or change any SQL. + - Internal writes that previously embedded `INSERT INTO knowledge_nodes (...)` statements gain two more columns (`domains = '[]'`, `domain_scores = '{}'`) in the INSERT list. These are non-optional columns after migration V12, and their DEFAULT is `'[]'`/`'{}'` respectively, so ALTER behaves correctly for pre-existing rows but INSERT statements need to either list the defaults explicitly or rely on the DB default. Plan: explicitly write `'[]'` and `'{}'` in every `INSERT INTO knowledge_nodes` statement to avoid surprises if a future migration drops the DEFAULT. + +--- + +## Test Plan + +### Unit tests (colocated, `#[cfg(test)] mod tests` at end of each source file) + +Every public trait method on `LocalMemoryStore` gets at least one unit test, exercised through the `SqliteMemoryStore` impl. The unit test file is `crates/vestige-core/src/storage/sqlite.rs` (inside the existing `mod tests`). + +- `vestige_core::storage::sqlite::tests::trait_init_is_idempotent` -- calling `LocalMemoryStore::init` twice returns `Ok(())` both times. +- `vestige_core::storage::sqlite::tests::trait_health_check_reports_healthy_on_fresh_db` -- asserts `HealthStatus::Healthy` on a fresh in-memory DB. +- `vestige_core::storage::sqlite::tests::trait_register_model_first_write_succeeds` -- after registering a signature, `registered_model()` returns it. +- `vestige_core::storage::sqlite::tests::trait_register_model_mismatched_write_refused` -- registering a second, different signature returns `MemoryStoreError::ModelMismatch`. +- `vestige_core::storage::sqlite::tests::trait_register_model_same_signature_idempotent` -- registering the same signature twice returns `Ok(())` both times. +- `vestige_core::storage::sqlite::tests::trait_insert_returns_uuid` -- `insert(record)` returns the UUID from the record. +- `vestige_core::storage::sqlite::tests::trait_insert_refuses_dimension_mismatch` -- inserting a record with a 512-dim vector into a store registered for 256 dims returns `MemoryStoreError::InvalidInput`. +- `vestige_core::storage::sqlite::tests::trait_get_missing_returns_none` -- `get(non_existent_uuid)` returns `Ok(None)`. +- `vestige_core::storage::sqlite::tests::trait_get_after_insert_round_trip` -- insert then get returns a record equal (by content/tags/type) to the input; `domains == []`, `domain_scores == {}`. +- `vestige_core::storage::sqlite::tests::trait_update_modifies_content` -- update with new content reflects in subsequent `get`. +- `vestige_core::storage::sqlite::tests::trait_delete_removes_record` -- `delete` then `get` returns `Ok(None)`. +- `vestige_core::storage::sqlite::tests::trait_search_combines_fts_and_vector` -- with one memory whose content matches by FTS and another by vector, `search` returns both, higher score for the exact content match. +- `vestige_core::storage::sqlite::tests::trait_fts_search_returns_tokens_match` -- verifies FTS path. +- `vestige_core::storage::sqlite::tests::trait_vector_search_returns_cosine_order` -- verifies ordering. +- `vestige_core::storage::sqlite::tests::trait_scheduling_round_trip` -- `update_scheduling` then `get_scheduling` returns equivalent state. +- `vestige_core::storage::sqlite::tests::trait_get_scheduling_missing_returns_none`. +- `vestige_core::storage::sqlite::tests::trait_get_due_memories_returns_in_order` -- inserts 3 records with different `next_review`, asserts older-due listed first. +- `vestige_core::storage::sqlite::tests::trait_add_edge_is_idempotent` -- adding the same edge twice does not duplicate. +- `vestige_core::storage::sqlite::tests::trait_get_edges_filters_by_type`. +- `vestige_core::storage::sqlite::tests::trait_remove_edge_deletes_single`. +- `vestige_core::storage::sqlite::tests::trait_get_neighbors_bfs_depth_zero_returns_self_only`. +- `vestige_core::storage::sqlite::tests::trait_get_neighbors_bfs_depth_two_expands` -- build A->B->C, get_neighbors(A, 2) returns {A, B, C}. +- `vestige_core::storage::sqlite::tests::trait_list_domains_empty_in_phase_1` -- Phase 1 has no clustering, so `list_domains()` returns `[]`. +- `vestige_core::storage::sqlite::tests::trait_upsert_then_get_domain_round_trip`. +- `vestige_core::storage::sqlite::tests::trait_delete_domain_idempotent`. +- `vestige_core::storage::sqlite::tests::trait_classify_with_no_domains_returns_empty` -- verifies Phase 1 stub behavior. +- `vestige_core::storage::sqlite::tests::trait_count_matches_insert_count`. +- `vestige_core::storage::sqlite::tests::trait_get_stats_reports_registered_model`. +- `vestige_core::storage::sqlite::tests::trait_vacuum_succeeds` -- runs and asserts no error. + +Every public method on `LocalEmbedder` gets at least one unit test under `crates/vestige-core/src/embedder/fastembed.rs`: + +- `vestige_core::embedder::fastembed::tests::embedder_reports_correct_name` -- `model_name()` contains "nomic". +- `vestige_core::embedder::fastembed::tests::embedder_reports_256_dimension`. +- `vestige_core::embedder::fastembed::tests::embedder_hash_is_stable` -- `model_hash()` called twice returns identical string. +- `vestige_core::embedder::fastembed::tests::embedder_hash_includes_crate_version` -- a synthetic test that asserts the hash contains the blake3 of `(name, 256, VERSION)`. +- `vestige_core::embedder::fastembed::tests::embedder_embed_smoke` -- gated on `#[cfg(feature = "embeddings")]`; asserts output length == 256. +- `vestige_core::embedder::fastembed::tests::embedder_embed_batch_matches_sequential` -- gated; assert batch result equals sequential result. +- `vestige_core::embedder::fastembed::tests::embedder_signature_matches_accessors`. + +Migration V12 unit tests under `crates/vestige-core/src/storage/migrations.rs`: + +- `vestige_core::storage::migrations::tests::v12_adds_embedding_model_table` -- apply V12 then assert `SELECT count(*) FROM sqlite_master WHERE name='embedding_model'` == 1. +- `vestige_core::storage::migrations::tests::v12_adds_domains_columns` -- assert `PRAGMA table_info(knowledge_nodes)` includes `domains` and `domain_scores`. +- `vestige_core::storage::migrations::tests::v12_default_values_empty_json` -- insert a row via raw SQL, read back, assert `domains == '[]'` and `domain_scores == '{}'`. +- `vestige_core::storage::migrations::tests::v12_is_replayable` -- rewind `schema_version` to 11, re-apply migrations, does not error (MUST use `CREATE TABLE IF NOT EXISTS`; `ALTER TABLE ADD COLUMN` will be skipped because the driver only re-runs migrations whose version > current -- already covered by `apply_migrations`). +- `vestige_core::storage::migrations::tests::v12_preserves_existing_rows` -- insert rows under V11 schema, upgrade to V12, assert `domains='[]'` on those rows. + +Supporting-type unit tests under `crates/vestige-core/src/storage/memory_store.rs`: + +- `vestige_core::storage::memory_store::tests::memory_store_error_from_storage_error` -- converts `StorageError::NotFound` to `MemoryStoreError::NotFound`. +- `vestige_core::storage::memory_store::tests::model_signature_serde_round_trip`. +- `vestige_core::storage::memory_store::tests::memory_record_serde_round_trip`. + +### Integration tests (`tests/phase_1/`) + +Each file is a standalone `[[test]]` target. The Cargo layout: + +- `tests/phase_1/Cargo.toml` with: + +```toml +[package] +name = "vestige-phase-1-tests" +version = "0.0.1" +edition = "2024" +publish = false + +[dependencies] +vestige-core = { path = "../../crates/vestige-core" } +tokio = { version = "1", features = ["macros", "rt-multi-thread"] } +tempfile = "3" +uuid = { version = "1", features = ["v4"] } +chrono = "0.4" +serde_json = "1" +rusqlite = { version = "0.38", features = ["bundled"] } +``` + +And added to the workspace `Cargo.toml` members. Each `.rs` file below is a `#[tokio::test]`-using integration test. + +#### `tests/phase_1/trait_round_trip.rs` + +- `round_trip::insert_get_update_delete` -- exercises CRUD via the trait. Inserts a record with `domains=[]`, gets it, asserts equality, updates content, deletes, asserts not found. +- `round_trip::scheduling_upsert_and_due_scan` -- upserts FSRS state for three memories with different `next_review`, calls `get_due_memories(Utc::now(), 10)`, asserts only past-due ones appear. +- `round_trip::edge_crud` -- add edge, list edges, remove edge, assert gone. +- `round_trip::search_hybrid_returns_results` -- insert three memories, embed one by content match only, one by semantic only, one by both, search with both `text` and `embedding`, assert all three appear with `fts_score`/`vector_score` correctly populated. +- `round_trip::count_and_stats_track_inserts` -- after 10 inserts, `count()` == 10 and `get_stats().total_memories` == 10. +- `round_trip::vacuum_after_deletes_reclaims` -- insert 50, delete 40, call `vacuum`, assert disk file size decreased (informational; test is lenient if VACUUM was a no-op). +- `round_trip::list_domains_empty_then_upsert_then_delete` -- Phase 1 has no discovery, but manual upsert/delete must work so Phase 2's Postgres impl can share the test. +- `round_trip::classify_with_no_domains_returns_empty` -- calls `classify(embedding)` on a fresh store, asserts `Vec<(String, f64)>` is empty. + +#### `tests/phase_1/embedding_model_registry.rs` + +- `model_registry::first_embedded_insert_auto_registers` -- fresh store; insert a record with a 256-dim vector using a `FastembedEmbedder`; subsequent `registered_model()` returns a `Some(ModelSignature)` with dim=256. +- `model_registry::second_insert_with_same_signature_succeeds`. +- `model_registry::second_insert_with_different_dimension_refused` -- register a 256-dim signature, try to insert a 512-dim vector, expect `MemoryStoreError::InvalidInput` (because dimension does not match registered). +- `model_registry::second_insert_with_different_model_name_refused` -- register signature A, call `register_model` with signature B (same dim, different name), expect `MemoryStoreError::ModelMismatch`. +- `model_registry::second_insert_with_different_hash_refused` -- register signature A, try to register signature A' with the same name and dim but a different hash, expect `MemoryStoreError::ModelMismatch`. +- `model_registry::no_embedding_insert_allowed_before_registration` -- a plain text memory without an embedding must insert successfully even when `registered_model()` is `None`. +- `model_registry::stats_reports_registered_model_after_first_write`. + +#### `tests/phase_1/domain_column_migration.rs` + +- `domain_columns::fresh_db_has_v12_schema` -- open a fresh store, query `PRAGMA table_info(knowledge_nodes)`, assert `domains` and `domain_scores` columns are present with the correct defaults. +- `domain_columns::v11_db_upgrades_cleanly` -- programmatically create a DB at V11 by running migrations up to V11 only, insert 5 rows, then invoke the V12 migration, assert all 5 rows now report `domains=='[]'` and `domain_scores=='{}'`. +- `domain_columns::empty_domains_serialize_as_brackets` -- insert a `MemoryRecord { domains: vec![], .. }`, then read the underlying SQLite row via a raw query, assert the stored value is `"[]"`, not `NULL`. +- `domain_columns::populated_domains_round_trip` -- insert a record with `domains=["dev","infra"]` and `domain_scores={"dev":0.82,"infra":0.71}`, read back via the trait, assert equality. +- `domain_columns::domains_table_exists` -- `SELECT name FROM sqlite_master WHERE name='domains'` returns one row. + +#### `tests/phase_1/cognitive_module_isolation.rs` + +- `cognitive_isolation::all_modules_compile_against_dyn_store` -- a test function that allocates a `let store: Arc = Arc::new(SqliteMemoryStore::new(...)?);`, then invokes a representative method from every cognitive module passing in records/vectors/edges it reads through the trait. The point is a compile-time gate: if any module still typed against `SqliteMemoryStore`, this would fail to compile. +- `cognitive_isolation::spreading_activation_traverses_via_trait` -- exercise `ActivationNetwork` seeded from `store.get_edges(...)` results. +- `cognitive_isolation::synaptic_tagging_consumes_records_via_trait` -- build `CapturedMemory` from `store.get(uuid)` and let the tagger compute retroactive importance. +- `cognitive_isolation::hippocampal_index_built_from_store` -- load memories via `store.fts_search`, build `HippocampalIndex`, assert queries against the index work. + +#### `tests/phase_1/send_bound_variant.rs` + +- `send_bound::arc_dyn_memory_store_moves_across_tokio_tasks` -- wrap `SqliteMemoryStore` in `Arc`, spawn 16 tokio tasks each inserting 10 memories, join all tasks, assert final `count() == 160`. This verifies the `#[trait_variant::make(MemoryStore: Send)]` emission actually produces a `Send`-bound future. +- `send_bound::concurrent_readers_one_writer` -- 32 concurrent readers calling `search` while one writer loops inserting; asserts no panics, no deadlocks, eventual consistency on `count`. + +#### `tests/phase_1/embedder_trait.rs` + +- `embedder::fastembed_implements_embedder_trait` -- `let e: Box = Box::new(FastembedEmbedder::new());` compiles and `e.dimension()` == 256. +- `embedder::signature_matches_memory_store_registry` -- take the signature from `Embedder::signature()`, register it via `MemoryStore::register_model`, assert `registered_model()` returns the same. + +### Regression verification + +- `cargo build -p vestige-core` -- zero warnings. +- `cargo build -p vestige-mcp` -- zero warnings. +- `cargo clippy --workspace --all-targets -- -D warnings` -- green. +- `cargo test -p vestige-core --lib` -- existing 352 core lib tests remain green. +- `cargo test -p vestige-mcp --lib` -- existing 406 mcp tests remain green. +- `cargo test -p vestige-core --lib storage::migrations::tests` -- explicitly invokes the migration tests added in Phase 1. +- `cargo test -p vestige-core --lib storage::sqlite::tests` -- invokes the trait-method unit tests added in Phase 1. +- `cargo test -p vestige-core --lib embedder::fastembed::tests` -- invokes embedder unit tests. +- `cargo test -p vestige-phase-1-tests --test trait_round_trip` -- Phase 1 integration test file 1. +- `cargo test -p vestige-phase-1-tests --test embedding_model_registry` -- Phase 1 integration test file 2. +- `cargo test -p vestige-phase-1-tests --test domain_column_migration` -- Phase 1 integration test file 3. +- `cargo test -p vestige-phase-1-tests --test cognitive_module_isolation` -- Phase 1 integration test file 4. +- `cargo test -p vestige-phase-1-tests --test send_bound_variant` -- Phase 1 integration test file 5. +- `cargo test -p vestige-phase-1-tests --test embedder_trait` -- Phase 1 integration test file 6. +- `cargo test -p vestige-phase-1-tests` -- convenience: runs all integration test binaries in the Phase 1 crate. +- `cargo test -p vestige-e2e` -- existing e2e harness runs unchanged; no new tests here but existing ones must pass. + +## Acceptance Criteria + +- [ ] `cargo build -p vestige-core` -- zero warnings. +- [ ] `cargo build -p vestige-mcp` -- zero warnings. +- [ ] `cargo build --workspace --all-targets` -- zero warnings. +- [ ] `cargo clippy --workspace --all-targets -- -D warnings` -- exits 0. +- [ ] `cargo test -p vestige-core` -- all 352 existing core tests plus new Phase 1 unit tests pass. +- [ ] `cargo test -p vestige-mcp` -- all 406 existing mcp tests pass, unchanged. +- [ ] `cargo test -p vestige-phase-1-tests` -- all Phase 1 integration tests pass. +- [ ] `cargo test -p vestige-e2e` -- existing e2e journey suite passes unchanged. +- [ ] Cumulative test count >= 758 (the pre-Phase-1 baseline) plus the new unit and integration additions. +- [ ] `git grep -n 'rusqlite::' crates/vestige-core/src/neuroscience/ crates/vestige-core/src/advanced/` -- zero hits (the single pre-existing doc-comment reference in `active_forgetting.rs` is acceptable and does not introduce SQL dependency; code references must be zero). +- [ ] `git grep -n 'SqliteMemoryStore' crates/vestige-core/src/neuroscience/ crates/vestige-core/src/advanced/` -- zero hits. +- [ ] `git grep -n 'fastembed::' crates/vestige-core/src/storage/sqlite.rs` -- zero hits (Storage must never call fastembed directly; embedding goes through the `Embedder` trait held on the caller side). +- [ ] `SqliteMemoryStore::insert` refuses a vector whose dimension disagrees with the registered model (returns `MemoryStoreError::InvalidInput`). +- [ ] `SqliteMemoryStore::register_model` returns `MemoryStoreError::ModelMismatch` when a second, different signature is provided after a first was already registered. +- [ ] After upgrading a V11 database to V12, every pre-existing row has `domains == "[]"` and `domain_scores == "{}"` with no NULLs. +- [ ] `#[trait_variant::make(MemoryStore: Send)]` compiles; `Arc` is movable across `tokio::spawn`. +- [ ] Migration V12 is idempotent on replay: `apply_migrations` rewound to V11, re-applied, succeeds without error. +- [ ] `vestige-core::storage::Storage` continues to resolve (via the `pub type` alias) at every current call site in `vestige-mcp`. +- [ ] The `embedding_model` table can only hold a single row (programmatic invariant -- verified by an integration test that attempts a second `INSERT INTO embedding_model (id = 1, ...)` and observes the CHECK-enforced uniqueness). +- [ ] `registered_model()` is cached on first read; no SELECT is issued against `embedding_model` after the first hit within the same process (verified by wrapping the reader in a counting proxy in a dedicated test). + +## Rollback Notes + +If Phase 1 fails mid-way, rollback granularity is per-deliverable and the DB can be downgraded by SQL. + +- **D1 (`memory_store.rs`)**: revert the new file. The trait has zero non-test consumers in Phase 1, so deletion is safe. +- **D2 (`storage/mod.rs`)**: revert to the prior export list. The only forward-facing identifier is the `pub type Storage = SqliteMemoryStore;` alias, which becomes `pub use sqlite::Storage;` again once `SqliteMemoryStore` is renamed back to `Storage`. +- **D3 (`sqlite.rs` rename + trait impl)**: revert the struct rename (`SqliteMemoryStore` -> `Storage`). The trait impl is a separate `impl` block and can be deleted wholesale. Inherent methods are unchanged and do not need to be touched. Net diff on revert: delete one `impl LocalMemoryStore for ...` block plus the two helper functions (`row_to_record`, `enforce_model`). +- **D4 (Migration V12)**: DOWN migration script: + +```sql +-- Phase 1 rollback: drop Phase 1 schema additions. +-- WARNING: this deletes any `domains` / `domain_scores` values stored under V12. +-- Execute ONLY when downgrading from V12 to V11 on a database where no Phase 4 +-- work has happened yet (otherwise you lose domain classifications). + +DROP TABLE IF EXISTS domains; +DROP INDEX IF EXISTS idx_nodes_domains; +DROP INDEX IF EXISTS idx_nodes_domain_scores; + +-- SQLite does not support DROP COLUMN before 3.35; the project's bundled +-- rusqlite uses 3.45+ (see `bundled-sqlite` feature). So the DROP COLUMN +-- form below is safe on every target platform. +ALTER TABLE knowledge_nodes DROP COLUMN domains; +ALTER TABLE knowledge_nodes DROP COLUMN domain_scores; + +DROP TABLE IF EXISTS embedding_model; + +UPDATE schema_version SET version = 11, applied_at = datetime('now'); +``` + + Operationally: the DOWN script is NOT included in the source migrations list (migrations are forward-only). If a rollback is required, it is applied manually via `sqlite3 vestige.db < rollback_v12.sql`. A backup via `storage.backup_to(...)` MUST be taken before the Phase 1 migration runs in production -- the `Storage::backup_to` method already exists (line 3903) and does not need changes. + +- **D5/D6 (`embedder/`)**: delete the module. `EmbeddingService` is untouched, so callers that still use it continue to work. The new `Embedder` trait has no pre-Phase-2 consumers. +- **D7 (`lib.rs`)**: revert the re-export additions. Zero downstream impact since the new symbols have no pre-Phase-2 consumers. +- **D8 (cognitive module audit)**: audit-only, no code changes. Nothing to roll back unless `consolidation/sleep.rs` was changed; if so, revert. +- **Crate-level considerations**: + - `trait-variant` must remain in `Cargo.toml` until every consumer of the trait alias has been reverted. Safe to leave in `[dependencies]` indefinitely; it has no runtime cost. + - `blake3` was going to be added in Phase 3 anyway; leaving it in on rollback is harmless. + - `rusqlite` version stays pinned; no bump required for Phase 1. + +## Open Implementation Questions + +Implementation-choice-only. Architectural questions are resolved in ADR 0001. + +1. **`MemoryRecord` vs `KnowledgeNode` as the trait currency.** + - Candidate A: `MemoryRecord` (new, lean type matching the PRD) -- chosen. + - Candidate B: use existing `KnowledgeNode` directly. + - **Recommendation: A.** `KnowledgeNode` carries 30+ FSRS / dual-strength / sentiment / temporal fields that bind callers to the SQLite columns. `MemoryRecord` is what `PgMemoryStore` and future backends will want. SQLite impl converts between the two at the boundary, which is a ~40-line `impl From for MemoryRecord` (and back) shim. Pays for itself in Phase 2. + +2. **`async fn` in traits vs `Box` via `async-trait`.** + - Candidate A: use `trait-variant` (RPITIT-based, MSRV 1.75+, our MSRV is 1.91). + - Candidate B: use `async-trait` (allocates one Box per call). + - **Recommendation: A.** `trait-variant` generates both the base `LocalMemoryStore` and the `Send`-bound `MemoryStore` from one definition, matches what the PRD explicitly calls out, and avoids the allocation overhead of boxed futures on every CRUD call. + +3. **Blocking SQLite under async signatures: spawn_blocking vs inline.** + - Candidate A: bodies call the existing sync `self.writer.lock()...` inline inside the `async fn`. + - Candidate B: bodies wrap in `tokio::task::spawn_blocking`. + - **Recommendation: A for Phase 1.** The current call sites are a mix of sync (CLI, bin/restore.rs) and async (MCP handlers). Introducing `spawn_blocking` would force a tokio runtime even for CLI use. Inline blocking under `async fn` is a documented pattern that compiles and works; under Phase 2 the Postgres impl uses `sqlx` which is natively async, and we can revisit Sqlite blocking policy at that point. Phase 1 priority is "no behavior change". + +4. **Where does `register_model` get called from: storage side auto-register, or caller-side explicit?** + - Candidate A: caller explicitly calls `store.register_model(embedder.signature())` once after `MemoryStore::init`. + - Candidate B: first `insert` with a vector auto-registers. + - **Recommendation: B.** The current code path (`Storage::ingest` -> `generate_embedding_for_node` -> INSERT into `node_embeddings`) has no explicit registration step and we want `--no behavior change`. Auto-register on first embedded write preserves the exact current UX. Callers who care (migration tooling, Phase 2 `--reembed`) can still call `register_model` explicitly; it is a no-op when idempotent. + +5. **`model_hash` content: fastembed ONNX bytes vs `(name, dim, crate_version)`.** + - Candidate A: hash the ONNX file bytes on disk (after model download). + - Candidate B: hash `(name, dim, vestige-core CARGO_PKG_VERSION)`. + - **Recommendation: B.** Fastembed caches ONNX files under `FASTEMBED_CACHE_PATH`; reading them from inside `FastembedEmbedder::new()` couples the embedder to fastembed's caching behavior and adds slow startup. Hashing `(name, dim, our crate version)` catches the "silent model drift between vestige versions" case the ADR calls out under Risks. Phase 2 can add a content-hashed `OnnxEmbedder` that loads any file and genuinely hashes it; the trait method signature stays the same. + +6. **`LocalMemoryStore` `Sync + 'static` or just `Sync`.** + - Candidate A: `Sync + 'static`. + - Candidate B: `Sync`. + - **Recommendation: A.** `'static` is required for `Arc` which is the target call pattern (Axum, MCP server, cognitive engine). Every impl we have in mind -- `SqliteMemoryStore`, `PgMemoryStore` -- holds owned state (connection pool, vector index), so `'static` is free. + +7. **Should trait methods appear on the SQLite impl instead of being separate?** + - Candidate A: keep the current ~85 inherent methods on `SqliteMemoryStore` AND add the `impl LocalMemoryStore` block. + - Candidate B: move every inherent method into the trait. + - **Recommendation: A.** Many inherent methods (e.g. `run_rac1_cascade_sweep`, `apply_rac1_cascade`, `save_insight`, `save_connection`, `preview_review`, `get_memory_subgraph`) have SQLite-specific semantics, transactional behavior, and call patterns that do not belong in a backend-agnostic trait. They will stay SQLite-only or be extracted into new traits in a post-Phase-4 cleanup. Phase 1's job is to expose the `~25 methods` contract the ADR specifies, not to retrofit the entire API. + +8. **Where do `Domain` bytes (centroid) live?** + - Candidate A: `BLOB` column on `domains` table. + - Candidate B: JSON-encoded array of f32 in a `TEXT` column. + - **Recommendation: A.** Consistent with how `node_embeddings.embedding` already stores vectors (little-endian f32 bytes via `Embedding::to_bytes`). JSON would triple the storage size and slow deserialization. The `Domain::centroid: Vec` field round-trips through the same codec. + +9. **Migration numbering when Phase 2 also wants to add a migration.** + - Candidate A: Phase 1 takes V12, Phase 2 takes V13. + - Candidate B: Phase 1 takes V12, Phase 2 re-shapes V12 to include its changes. + - **Recommendation: A.** Migrations are forward-only and append-only in this project. Phase 2 adds V13 (for `review_events` append-only table, if that lands in Phase 2 -- otherwise it is Phase 5 work). + +10. **Integration test crate location: sibling to `tests/e2e/` or inside `crates/vestige-core/tests/`.** + - Candidate A: new workspace member at `tests/phase_1/` (sibling to `tests/e2e/`). + - Candidate B: under `crates/vestige-core/tests/` (standard cargo integration-test layout). + - **Recommendation: A.** Matches the existing pattern of `tests/e2e/`, which is already a workspace member with its own `Cargo.toml`. Keeps the Phase 1 test binary outputs in a predictable location (`target/debug/deps/trait_round_trip-*`). Also avoids the build-graph cycle where `crates/vestige-core/tests/` would re-link everything under `vestige-core` each edit. + +### Critical Files for Implementation + +- /home/delandtj/prppl/vestige/crates/vestige-core/src/storage/memory_store.rs (new; contains the `LocalMemoryStore` / `MemoryStore` traits plus `MemoryRecord`, `SchedulingState`, `SearchQuery`, `SearchResult`, `MemoryEdge`, `Domain`, `ClassificationResult`, `StoreStats`, `HealthStatus`, `MemoryStoreError`, `ModelSignature`) +- /home/delandtj/prppl/vestige/crates/vestige-core/src/storage/sqlite.rs (rename `Storage` -> `SqliteMemoryStore`, add the `impl LocalMemoryStore` block and the `enforce_model` / `row_to_record` helpers; ~200 line diff on a 4592-line file) +- /home/delandtj/prppl/vestige/crates/vestige-core/src/storage/migrations.rs (append `Migration { version: 12, ... }` + `MIGRATION_V12_UP` constant; ~80 new lines) +- /home/delandtj/prppl/vestige/crates/vestige-core/src/embedder/mod.rs (new; `Embedder` + `LocalEmbedder` traits, `EmbedderError`, default `embed_batch`) +- /home/delandtj/prppl/vestige/crates/vestige-core/src/embedder/fastembed.rs (new; `FastembedEmbedder` implementation adapting the existing `EmbeddingService`) diff --git a/docs/plans/0002-phase-2-postgres-backend.md b/docs/plans/0002-phase-2-postgres-backend.md new file mode 100644 index 0000000..a372e27 --- /dev/null +++ b/docs/plans/0002-phase-2-postgres-backend.md @@ -0,0 +1,1269 @@ +# Phase 2 Plan: PostgreSQL Backend + +**Status**: Draft +**Depends on**: Phase 1 (MemoryStore + Embedder traits, embedding_model registry, domain columns) +**Related**: docs/adr/0001-pluggable-storage-and-network-access.md (Phase 2), docs/prd/001-getting-centralized-vestige.md + +--- + +## Scope + +### In scope + +- `PgMemoryStore` struct implementing the Phase 1 `MemoryStore` trait against `sqlx::PgPool`, including compile-time checked queries via `sqlx::query!` / `sqlx::query_as!`. +- First-class `pgvector` integration: typed `Vector` columns, HNSW index (`vector_cosine_ops`, `m = 16`, `ef_construction = 64`), and use of the cosine-distance operator `<=>`. +- First-class Postgres FTS: GENERATED `tsvector` column (`search_vec`) with `setweight` (A=content, B=node_type, C=tags), GIN index, and `websearch_to_tsquery` at query time. +- Hybrid search via Reciprocal Rank Fusion (RRF) expressed as a single SQL statement with CTEs for FTS and vector subqueries, with optional domain filter through array overlap (`&&`). +- sqlx migrations directory at `crates/vestige-core/migrations/postgres/`, numbered `{NNNN}_{name}.up.sql` / `{NNNN}_{name}.down.sql`, runnable by `sqlx::migrate!` at startup and by `sqlx-cli`. +- Offline query cache committed under `crates/vestige-core/.sqlx/` so a DATABASE_URL is not required at build time. +- Backend selection via `vestige.toml`: `[storage]` section with `backend = "sqlite" | "postgres"` plus the per-backend subsection (`[storage.sqlite]`, `[storage.postgres]`). Exclusive at compile time via `postgres-backend` feature, exclusive at runtime via the enum. +- CLI: `vestige migrate --from sqlite --to postgres --sqlite-path

--postgres-url ` -- streaming copy with progress output. +- CLI: `vestige migrate --reembed --model=` -- O(n) re-embed under a new `Embedder`, registry update, HNSW rebuild. +- Testcontainer-based integration tests using the `pgvector/pgvector:pg16` image, behind the `postgres-backend` feature so SQLite-only builds remain untouched. +- `PgMemoryStore` parity with `SqliteMemoryStore` across every public `MemoryStore` method defined in Phase 1. + +### Out of scope + +- Phase 3 (network access): HTTP MCP transport, API key auth, `vestige keys` CLI. The `api_keys` DDL is declared by Phase 3; Phase 2 does not create it. +- Phase 4 (emergent domain classification): `DomainClassifier`, HDBSCAN, discover / rename / merge CLI. Phase 2 provisions the `domains` and `domain_scores` columns and the `domains` table structure so Phase 4 slots in without further migration, but does not compute or classify. +- Phase 5 (federation): cross-node sync. The `review_events` table is declared in Phase 1; Phase 2 only references it where FSRS writes happen. +- Changes to the cognitive engine, Phase 1 traits, or the embedding pipeline itself. Phase 2 only adds a backend. +- SQLCipher parity for Postgres. Operator responsibility (TLS to Postgres, pgcrypto, disk-level encryption) is out of scope for this phase. + +--- + +## Prerequisites + +### Expected Phase 1 artifacts (consumed, not produced) + +Phase 2 treats all of the following as fixed interfaces. Each path is the expected Phase 1 location. + +- `crates/vestige-core/src/storage/mod.rs` -- re-exports the trait and the two concrete backends. +- `crates/vestige-core/src/storage/memory_store.rs` -- defines the `MemoryStore` trait (generated by `trait_variant::make` from `LocalMemoryStore`) with the full CRUD, search, FSRS, graph, and domain surface from the PRD. Phase 2 implements every method here. +- `crates/vestige-core/src/storage/types.rs` -- shared value types: `MemoryRecord`, `SchedulingState`, `SearchQuery`, `SearchResult`, `MemoryEdge`, `Domain`, `StoreStats`, `HealthStatus`. +- `crates/vestige-core/src/storage/error.rs` -- `StoreError` enum plus `pub type StoreResult = Result`. Phase 2 extends this with `StoreError::Postgres(sqlx::Error)` and `StoreError::Migrate(sqlx::migrate::MigrateError)` via `From` impls (the variants themselves MUST live behind `#[cfg(feature = "postgres-backend")]`). +- `crates/vestige-core/src/embedder/mod.rs` -- `Embedder` trait with `embed`, `model_name`, `dimension`, `model_hash`. Phase 2 calls `model_name()`, `dimension()`, and `model_hash()` for the registry. +- `crates/vestige-core/src/storage/sqlite.rs` -- `SqliteMemoryStore: MemoryStore`. Phase 2's `migrate --from sqlite --to postgres` uses this as the source. +- `crates/vestige-core/src/storage/registry.rs` -- `EmbeddingModelRegistry` abstraction that both backends implement. Phase 2 supplies a Postgres version writing to `embedding_model`. +- `crates/vestige-core/migrations/sqlite/` -- V12 (Phase 1) adds `domains TEXT` (JSON-encoded array), `domain_scores TEXT` (JSON), `embedding_model(name, dimension, hash, created_at)`, and `review_events(id, memory_id, timestamp, rating, prior_state, new_state)`. Phase 2 mirrors every column and table in Postgres. + +If any of the above is missing when Phase 2 starts, the first action is to surface the gap back to Phase 1 -- do NOT backfill a partial trait in Phase 2. + +### Required crates (declared in Phase 2, not installed by this doc) + +The agent running Phase 2 uses `cargo add` in `crates/vestige-core/` for each dependency below. Exact versions and feature flags: + +- `sqlx@0.8` with features `runtime-tokio`, `tls-rustls`, `postgres`, `uuid`, `chrono`, `json`, `migrate`, `macros`. Optional (gated by `postgres-backend`). +- `pgvector@0.4` with features `sqlx`. Optional (gated by `postgres-backend`). +- `deadpool` is NOT needed; `sqlx::PgPool` is the pool. +- `toml@0.8` (no features) for `vestige.toml` parsing. Moved to non-optional because both backends share the config surface. +- `figment@0.10` with features `toml`, `env` -- optional, only if Phase 1 has not already picked a config loader. If Phase 1 ships a loader, skip `figment` and reuse. +- `dirs@6` -- already a transitive `directories` dependency; reuse existing. +- `tokio-stream@0.1` (no features). Used by migrate commands for streamed iteration. +- `indicatif@0.17` (no features). Progress bars for the migrate CLI. +- `futures@0.3` with features `std`. Consumed by sqlx stream combinators. + +Dev-only (under `[dev-dependencies]` in `crates/vestige-core/Cargo.toml`, gated by `postgres-backend`): + +- `testcontainers@0.22` with features `blocking` off, `async` on (default). +- `testcontainers-modules@0.10` with features `postgres`. +- `tokio@1` features `macros`, `rt-multi-thread` (already present for core tests). +- `criterion@0.5` already present; add a new `[[bench]]` entry. + +Feature additions in `crates/vestige-core/Cargo.toml`: + +``` +[features] +postgres-backend = ["dep:sqlx", "dep:pgvector", "dep:tokio-stream", "dep:futures"] +``` + +`postgres-backend` is OFF by default. `default = ["embeddings", "vector-search", "bundled-sqlite"]` stays unchanged. `vestige-mcp` forwards a new feature `postgres-backend = ["vestige-core/postgres-backend"]`. + +### External tooling + +- PostgreSQL 16 or newer (uses `gen_random_uuid()` from `pgcrypto` bundled via `CREATE EXTENSION pgcrypto` in migration 0001; pgvector HNSW indexes require pgvector 0.5+). +- The `pgvector` extension installed in the target database (our migration issues `CREATE EXTENSION IF NOT EXISTS vector`). +- `sqlx-cli@0.8` installed on the developer machine for `cargo sqlx prepare --workspace` and `cargo sqlx migrate add` (not a build-time requirement once `.sqlx/` is committed). +- Docker or Podman reachable by the test harness for `testcontainers-modules::postgres` to spin up `pgvector/pgvector:pg16`. + +### Assumed Rust toolchain + +- Rust 2024 edition. +- MSRV 1.91 (per `CLAUDE.md`). `sqlx 0.8` is compatible. +- `rustflags` unchanged. No `nightly`-only features. + +--- + +## Deliverables + +1. Feature gate `postgres-backend` in `crates/vestige-core/Cargo.toml` and `crates/vestige-mcp/Cargo.toml` that cleanly disables all Postgres code paths when off. +2. `crates/vestige-core/src/storage/postgres/mod.rs` -- `PgMemoryStore` struct and `MemoryStore` trait impl (public entry point). +3. `crates/vestige-core/src/storage/postgres/pool.rs` -- `PgMemoryStore::connect(config)` and pool configuration. +4. `crates/vestige-core/src/storage/postgres/search.rs` -- RRF hybrid search query builder and row -> `SearchResult` mapping. +5. `crates/vestige-core/src/storage/postgres/migrations.rs` -- wraps `sqlx::migrate!("./migrations/postgres")` and surfaces typed errors. +6. `crates/vestige-core/src/storage/postgres/registry.rs` -- Postgres `EmbeddingModelRegistry` implementation writing `embedding_model`. +7. `crates/vestige-core/migrations/postgres/0001_init.up.sql` + `0001_init.down.sql` -- extensions, `memories`, `scheduling`, `edges`, `domains`, `embedding_model`, `review_events`, all indexes. +8. `crates/vestige-core/migrations/postgres/0002_hnsw.up.sql` + `0002_hnsw.down.sql` -- HNSW index creation separated so it can be `CREATE INDEX CONCURRENTLY` during reembed. +9. `crates/vestige-core/src/config.rs` -- `VestigeConfig`, `StorageConfig`, `SqliteConfig`, `PostgresConfig`, `EmbeddingsConfig`, plus a single `VestigeConfig::load(path: Option<&Path>)` returning `Result`. +10. `crates/vestige-core/src/storage/postgres/migrate_cli.rs` -- streaming SQLite-to-Postgres copy, domain-aware, with `indicatif` progress. +11. `crates/vestige-core/src/storage/postgres/reembed.rs` -- `ReembedPlan` and its driver; re-encodes all memories via a supplied `Embedder`, updates `embedding_model`, rebuilds HNSW. +12. `crates/vestige-mcp/src/bin/cli.rs` -- two new `clap` subcommands `Migrate` (union of `--from/--to` and `--reembed` variants, one subcommand or two, see Open Questions) wired to deliverables 10 and 11. +13. `crates/vestige-core/.sqlx/` -- offline query cache, committed. +14. `tests/phase_2/` -- six integration test files listed in the Test Plan. +15. `crates/vestige-core/benches/pg_hybrid_search.rs` -- Criterion benches for RRF search at 1k and 100k memories, gated by `postgres-backend`. +16. `docs/runbook/postgres.md` -- brief ops note covering extension install, `max_connections`, backup discipline, and rollback caveats. (Short; only required for the "rollback of migrate" deliverable.) + +--- + +## Detailed Task Breakdown + +### D1. `postgres-backend` feature gate + +- **File**: `crates/vestige-core/Cargo.toml`, `crates/vestige-mcp/Cargo.toml` +- **Depends on**: nothing; this is the first change. +- **Rust snippets**: + +```toml +# crates/vestige-core/Cargo.toml +[features] +default = ["embeddings", "vector-search", "bundled-sqlite"] +bundled-sqlite = ["rusqlite/bundled"] +encryption = ["rusqlite/bundled-sqlcipher"] +postgres-backend = [ + "dep:sqlx", + "dep:pgvector", + "dep:tokio-stream", + "dep:futures", +] + +[dependencies] +sqlx = { version = "0.8", default-features = false, features = [ + "runtime-tokio", "tls-rustls", "postgres", "uuid", "chrono", + "json", "migrate", "macros", +], optional = true } +pgvector = { version = "0.4", features = ["sqlx"], optional = true } +tokio-stream = { version = "0.1", optional = true } +futures = { version = "0.3", optional = true } +toml = "0.8" +indicatif = "0.17" +``` + +- **Behavior notes**: keep the two backends mutually compilable per `CLAUDE.md`. Every `use sqlx::...` sits under `#[cfg(feature = "postgres-backend")]`. Every module under `crates/vestige-core/src/storage/postgres/` carries `#![cfg(feature = "postgres-backend")]` as its file-level attribute. + +### D2. `PgMemoryStore` core struct + +- **File**: `crates/vestige-core/src/storage/postgres/mod.rs` +- **Depends on**: D1, Phase 1 `MemoryStore` trait and value types. +- **Signatures**: + +```rust +#![cfg(feature = "postgres-backend")] + +use std::sync::Arc; +use std::time::Duration; + +use chrono::{DateTime, Utc}; +use pgvector::Vector; +use sqlx::postgres::{PgConnectOptions, PgPoolOptions}; +use sqlx::PgPool; +use uuid::Uuid; + +use crate::embedder::Embedder; +use crate::storage::error::{StoreError, StoreResult}; +use crate::storage::types::{ + Domain, HealthStatus, MemoryEdge, MemoryRecord, SchedulingState, + SearchQuery, SearchResult, StoreStats, +}; +use crate::storage::memory_store::LocalMemoryStore; + +pub mod migrations; +pub mod pool; +pub mod registry; +pub mod search; +pub mod migrate_cli; +pub mod reembed; + +/// Postgres-backed implementation of `MemoryStore`. +/// +/// Cheaply cloneable. Methods take `&self`; interior state lives inside +/// the `PgPool` (which already provides `Sync` via `Arc` internally). +#[derive(Clone)] +pub struct PgMemoryStore { + pool: PgPool, + embedding_dim: i32, + embedding_model: Arc, +} + +#[derive(Debug, Clone)] +pub struct EmbeddingModelDescriptor { + pub name: String, + pub dimension: i32, + pub hash: String, +} + +impl PgMemoryStore { + /// Construct a new store. Runs migrations, reads the registry, validates + /// that the embedder matches the registered model. + pub async fn connect( + url: &str, + max_connections: u32, + embedder: &dyn Embedder, + ) -> StoreResult; + + /// Low-level constructor for tests: supply an existing pool, skip migrate. + pub async fn from_pool( + pool: PgPool, + embedder: &dyn Embedder, + ) -> StoreResult; + + /// Accessor used by migrate/reembed CLI. + pub fn pool(&self) -> &PgPool { &self.pool } + + pub fn embedding_dim(&self) -> i32 { self.embedding_dim } +} + +#[trait_variant::make(crate::storage::memory_store::MemoryStore: Send)] +impl LocalMemoryStore for PgMemoryStore { + async fn init(&self) -> StoreResult<()>; + async fn health_check(&self) -> StoreResult; + + async fn insert(&self, record: &MemoryRecord) -> StoreResult; + async fn get(&self, id: Uuid) -> StoreResult>; + async fn update(&self, record: &MemoryRecord) -> StoreResult<()>; + async fn delete(&self, id: Uuid) -> StoreResult<()>; + + async fn search(&self, query: &SearchQuery) -> StoreResult>; + async fn fts_search(&self, text: &str, limit: usize) -> StoreResult>; + async fn vector_search(&self, embedding: &[f32], limit: usize) -> StoreResult>; + + async fn get_scheduling(&self, memory_id: Uuid) -> StoreResult>; + async fn update_scheduling(&self, state: &SchedulingState) -> StoreResult<()>; + async fn get_due_memories( + &self, + before: DateTime, + limit: usize, + ) -> StoreResult>; + + async fn add_edge(&self, edge: &MemoryEdge) -> StoreResult<()>; + async fn get_edges(&self, node_id: Uuid, edge_type: Option<&str>) -> StoreResult>; + async fn remove_edge(&self, source: Uuid, target: Uuid, edge_type: &str) -> StoreResult<()>; + async fn get_neighbors(&self, node_id: Uuid, depth: usize) -> StoreResult>; + + async fn list_domains(&self) -> StoreResult>; + async fn get_domain(&self, id: &str) -> StoreResult>; + async fn upsert_domain(&self, domain: &Domain) -> StoreResult<()>; + async fn delete_domain(&self, id: &str) -> StoreResult<()>; + async fn classify(&self, embedding: &[f32]) -> StoreResult>; + + async fn count(&self) -> StoreResult; + async fn get_stats(&self) -> StoreResult; + async fn vacuum(&self) -> StoreResult<()>; +} +``` + +- **SQL (inline within impl methods)**: every call uses `sqlx::query!` or `sqlx::query_as!` for compile-time validation. Examples: + +```rust +// insert +sqlx::query!( + r#" + INSERT INTO memories ( + id, domains, domain_scores, content, node_type, tags, + embedding, metadata, created_at, updated_at + ) VALUES ($1, $2, $3, $4, $5, $6, $7::vector, $8, $9, $10) + "#, + record.id, + &record.domains as &[String], + serde_json::to_value(&record.domain_scores)?, + record.content, + record.node_type, + &record.tags as &[String], + record.embedding.as_ref().map(|v| Vector::from(v.clone())) as Option, + record.metadata, + record.created_at, + record.updated_at, +) +.execute(&self.pool) +.await?; +``` + +- **Behavior notes**: + - `StoreError` gets two new variants behind the feature: + +```rust +#[cfg(feature = "postgres-backend")] +#[error("postgres error: {0}")] +Postgres(#[from] sqlx::Error), + +#[cfg(feature = "postgres-backend")] +#[error("postgres migration error: {0}")] +Migrate(#[from] sqlx::migrate::MigrateError), +``` + + - `classify()` on Postgres implements the PRD's cosine-similarity-to-centroid computation inside SQL using `1 - (centroid <=> $1::vector)` over the `domains` table and returns rows sorted descending. This mirrors the behavior a `DomainClassifier` in Phase 4 uses; Phase 2 ships the backend capability but does not call it. + - Connection pool defaults (see D3): `max_connections = 10`, `acquire_timeout = 30s`, `idle_timeout = 600s`, `test_before_acquire = false` (cheap queries; avoid per-acquire roundtrip). + - All methods are `async fn` and use sqlx's `tokio` runtime feature; no blocking `block_on`. + +### D3. Pool construction and config wiring + +- **File**: `crates/vestige-core/src/storage/postgres/pool.rs` +- **Depends on**: D1, D2, D9. +- **Signatures**: + +```rust +#![cfg(feature = "postgres-backend")] + +use sqlx::postgres::{PgConnectOptions, PgPoolOptions}; +use sqlx::{ConnectOptions, PgPool}; +use std::str::FromStr; +use std::time::Duration; + +use crate::config::PostgresConfig; +use crate::storage::error::{StoreError, StoreResult}; + +pub async fn build_pool(cfg: &PostgresConfig) -> StoreResult { + let mut opts = PgConnectOptions::from_str(&cfg.url)?; + opts = opts + .application_name("vestige") + .statement_cache_capacity(256) + .log_statements(tracing::log::LevelFilter::Debug); + + let pool = PgPoolOptions::new() + .max_connections(cfg.max_connections.unwrap_or(10)) + .min_connections(0) + .acquire_timeout(Duration::from_secs(cfg.acquire_timeout_secs.unwrap_or(30))) + .idle_timeout(Some(Duration::from_secs(600))) + .max_lifetime(Some(Duration::from_secs(1800))) + .test_before_acquire(false) + .connect_with(opts) + .await?; + + Ok(pool) +} +``` + +- **Behavior notes**: acquire timeout chosen to exceed the 30-second testcontainer spin-up requirement. `application_name = "vestige"` makes `pg_stat_activity` readable from `psql` during debugging. + +### D4. sqlx migrations directory + +- **File**: `crates/vestige-core/migrations/postgres/0001_init.up.sql`, `0001_init.down.sql`, `0002_hnsw.up.sql`, `0002_hnsw.down.sql`. +- **Depends on**: none (pure SQL). + +`0001_init.up.sql`: + +```sql +-- Extensions +CREATE EXTENSION IF NOT EXISTS pgcrypto; +CREATE EXTENSION IF NOT EXISTS vector; + +-- Embedding model registry +-- Mirrors the SQLite table created in Phase 1. +CREATE TABLE embedding_model ( + id SMALLINT PRIMARY KEY DEFAULT 1 CHECK (id = 1), + name TEXT NOT NULL, + dimension INTEGER NOT NULL CHECK (dimension > 0), + hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Domains table (populated by Phase 4 DomainClassifier; Phase 2 only creates +-- the empty table so list/get/upsert/delete work against both backends). +CREATE TABLE domains ( + id TEXT PRIMARY KEY, + label TEXT NOT NULL, + centroid vector, + top_terms TEXT[] NOT NULL DEFAULT '{}', + memory_count INTEGER NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb +); + +-- Core memories table +CREATE TABLE memories ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + domains TEXT[] NOT NULL DEFAULT '{}', + domain_scores JSONB NOT NULL DEFAULT '{}'::jsonb, + content TEXT NOT NULL, + node_type TEXT NOT NULL DEFAULT 'general', + tags TEXT[] NOT NULL DEFAULT '{}', + embedding vector, + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), + search_vec TSVECTOR GENERATED ALWAYS AS ( + setweight(to_tsvector('english', coalesce(content, '')), 'A') || + setweight(to_tsvector('english', coalesce(node_type, '')), 'B') || + setweight(to_tsvector('english', coalesce(array_to_string(tags, ' '), '')), 'C') + ) STORED +); + +-- FSRS scheduling state (1:1 with memories) +CREATE TABLE scheduling ( + memory_id UUID PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE, + stability DOUBLE PRECISION NOT NULL DEFAULT 0.0, + difficulty DOUBLE PRECISION NOT NULL DEFAULT 0.0, + retrievability DOUBLE PRECISION NOT NULL DEFAULT 1.0, + last_review TIMESTAMPTZ, + next_review TIMESTAMPTZ, + reps INTEGER NOT NULL DEFAULT 0, + lapses INTEGER NOT NULL DEFAULT 0 +); + +-- Graph edges (spreading activation) +CREATE TABLE edges ( + source_id UUID NOT NULL REFERENCES memories(id) ON DELETE CASCADE, + target_id UUID NOT NULL REFERENCES memories(id) ON DELETE CASCADE, + edge_type TEXT NOT NULL DEFAULT 'related', + weight DOUBLE PRECISION NOT NULL DEFAULT 1.0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (source_id, target_id, edge_type) +); + +-- FSRS review event log (Phase 1 creates this; Phase 2 mirrors it for Postgres). +-- Append-only. Used for future federation (Phase 5). +CREATE TABLE review_events ( + id BIGSERIAL PRIMARY KEY, + memory_id UUID NOT NULL REFERENCES memories(id) ON DELETE CASCADE, + timestamp TIMESTAMPTZ NOT NULL DEFAULT now(), + rating SMALLINT NOT NULL, + prior_state JSONB NOT NULL, + new_state JSONB NOT NULL +); + +-- Indexes on memories (vector index is declared separately in 0002_hnsw.up.sql) +CREATE INDEX idx_memories_fts ON memories USING GIN (search_vec); +CREATE INDEX idx_memories_domains ON memories USING GIN (domains); +CREATE INDEX idx_memories_tags ON memories USING GIN (tags); +CREATE INDEX idx_memories_node_type ON memories (node_type); +CREATE INDEX idx_memories_created ON memories (created_at); +CREATE INDEX idx_memories_updated ON memories (updated_at); + +-- Indexes on scheduling +CREATE INDEX idx_scheduling_next_review ON scheduling (next_review); +CREATE INDEX idx_scheduling_last_review ON scheduling (last_review); + +-- Indexes on edges +CREATE INDEX idx_edges_target ON edges (target_id); +CREATE INDEX idx_edges_source ON edges (source_id); +CREATE INDEX idx_edges_type ON edges (edge_type); + +-- Indexes on review_events +CREATE INDEX idx_review_events_memory ON review_events (memory_id); +CREATE INDEX idx_review_events_ts ON review_events (timestamp); + +-- Update trigger on memories.updated_at +CREATE OR REPLACE FUNCTION memories_set_updated_at() RETURNS TRIGGER AS $$ +BEGIN + NEW.updated_at := now(); + RETURN NEW; +END; +$$ LANGUAGE plpgsql; + +CREATE TRIGGER trg_memories_updated_at +BEFORE UPDATE ON memories +FOR EACH ROW EXECUTE FUNCTION memories_set_updated_at(); +``` + +`0001_init.down.sql`: + +```sql +DROP TRIGGER IF EXISTS trg_memories_updated_at ON memories; +DROP FUNCTION IF EXISTS memories_set_updated_at(); + +DROP INDEX IF EXISTS idx_review_events_ts; +DROP INDEX IF EXISTS idx_review_events_memory; +DROP INDEX IF EXISTS idx_edges_type; +DROP INDEX IF EXISTS idx_edges_source; +DROP INDEX IF EXISTS idx_edges_target; +DROP INDEX IF EXISTS idx_scheduling_last_review; +DROP INDEX IF EXISTS idx_scheduling_next_review; +DROP INDEX IF EXISTS idx_memories_updated; +DROP INDEX IF EXISTS idx_memories_created; +DROP INDEX IF EXISTS idx_memories_node_type; +DROP INDEX IF EXISTS idx_memories_tags; +DROP INDEX IF EXISTS idx_memories_domains; +DROP INDEX IF EXISTS idx_memories_fts; + +DROP TABLE IF EXISTS review_events; +DROP TABLE IF EXISTS edges; +DROP TABLE IF EXISTS scheduling; +DROP TABLE IF EXISTS memories; +DROP TABLE IF EXISTS domains; +DROP TABLE IF EXISTS embedding_model; +``` + +`0002_hnsw.up.sql` (separated so reembed can drop-and-recreate without touching the rest of the schema): + +```sql +-- HNSW index on memories.embedding. +-- pgvector requires the column to have a typmod (fixed dimension) for HNSW. +-- The dimension is stamped by the application at startup via ALTER TABLE +-- using the embedder's dimension() method (see PgMemoryStore::connect). +-- We express the index with the generic vector_cosine_ops operator class. +CREATE INDEX idx_memories_embedding_hnsw + ON memories USING hnsw (embedding vector_cosine_ops) + WITH (m = 16, ef_construction = 64); +``` + +`0002_hnsw.down.sql`: + +```sql +DROP INDEX IF EXISTS idx_memories_embedding_hnsw; +``` + +- **Behavior notes**: + - pgvector HNSW requires a typmod. `PgMemoryStore::connect` runs `ALTER TABLE memories ALTER COLUMN embedding TYPE vector($N)` with `$N = embedder.dimension()` exactly once, guarded by a check against `embedding_model` (first startup ever) or validated against it on subsequent starts. If `embedder.dimension()` differs from the stored one and `embedding_model` is non-empty, return `StoreError::EmbeddingDimensionMismatch` -- the user must run `vestige migrate --reembed`. + - `ALTER COLUMN ... TYPE vector($N)` on a populated column fails unless the data fits; that is the desired safety net. + - The `tsvector` GENERATED column uses `array_to_string(tags, ' ')` rather than `array_to_tsvector` from the PRD sketch, because `array_to_tsvector` is not a core function in Postgres 16 and would require an extension. The behavior is equivalent for weight C. + - `gen_random_uuid()` comes from `pgcrypto`. In Postgres 13+ it is also available from core; we keep the extension for older compatibility paths. + - MVCC: all table writes are transactional; no explicit locks. `INSERT ... ON CONFLICT DO UPDATE` is used in `upsert_domain`, `update_scheduling`, and edge idempotency. + +### D5. Hybrid search via RRF + +- **File**: `crates/vestige-core/src/storage/postgres/search.rs` +- **Depends on**: D2, D4. +- **Signatures**: + +```rust +#![cfg(feature = "postgres-backend")] + +use pgvector::Vector; +use sqlx::PgPool; +use uuid::Uuid; + +use crate::storage::error::StoreResult; +use crate::storage::types::{SearchQuery, SearchResult}; + +const RRF_K: i32 = 60; // constant from Cormack et al. 2009 +const OVERFETCH_MULT: i64 = 3; // matches Phase 1 SQLite overfetch + +pub(crate) async fn rrf_search( + pool: &PgPool, + query: &SearchQuery, +) -> StoreResult>; +``` + +SQL for the full hybrid RRF query. Placeholders: +- `$1` = text query (string, may be empty) +- `$2` = embedding (vector) +- `$3` = overfetch limit per branch (int) +- `$4` = final limit (int) +- `$5` = domain filter (text[] or NULL) +- `$6` = node_type filter (text[] or NULL) +- `$7` = tag filter (text[] or NULL) + +```sql +WITH params AS ( + SELECT + $1::text AS q_text, + $2::vector AS q_vec, + $3::int AS overfetch, + $4::int AS final_limit, + $5::text[] AS dom_filter, + $6::text[] AS nt_filter, + $7::text[] AS tag_filter +), +fts AS ( + SELECT m.id, + ts_rank_cd(m.search_vec, websearch_to_tsquery('english', p.q_text)) AS score, + ROW_NUMBER() OVER ( + ORDER BY ts_rank_cd(m.search_vec, websearch_to_tsquery('english', p.q_text)) DESC + ) AS rank + FROM memories m, params p + WHERE p.q_text <> '' + AND m.search_vec @@ websearch_to_tsquery('english', p.q_text) + AND (p.dom_filter IS NULL OR m.domains && p.dom_filter) + AND (p.nt_filter IS NULL OR m.node_type = ANY(p.nt_filter)) + AND (p.tag_filter IS NULL OR m.tags && p.tag_filter) + LIMIT (SELECT overfetch FROM params) +), +vec AS ( + SELECT m.id, + 1 - (m.embedding <=> p.q_vec) AS score, + ROW_NUMBER() OVER ( + ORDER BY m.embedding <=> p.q_vec + ) AS rank + FROM memories m, params p + WHERE m.embedding IS NOT NULL + AND p.q_vec IS NOT NULL + AND (p.dom_filter IS NULL OR m.domains && p.dom_filter) + AND (p.nt_filter IS NULL OR m.node_type = ANY(p.nt_filter)) + AND (p.tag_filter IS NULL OR m.tags && p.tag_filter) + LIMIT (SELECT overfetch FROM params) +), +fused AS ( + SELECT COALESCE(f.id, v.id) AS id, + COALESCE(1.0 / (60 + f.rank), 0.0) + + COALESCE(1.0 / (60 + v.rank), 0.0) AS rrf_score, + f.score AS fts_score, + v.score AS vector_score + FROM fts f FULL OUTER JOIN vec v ON f.id = v.id +) +SELECT m.id AS "id!: Uuid", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.content AS "content!", + m.node_type AS "node_type!", + m.tags AS "tags!: Vec", + m.embedding AS "embedding?: Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: chrono::DateTime", + m.updated_at AS "updated_at!: chrono::DateTime", + fused.rrf_score AS "rrf_score!: f64", + fused.fts_score AS "fts_score?: f64", + fused.vector_score AS "vector_score?: f64" +FROM fused +JOIN memories m ON m.id = fused.id +ORDER BY fused.rrf_score DESC +LIMIT (SELECT final_limit FROM params); +``` + +- **Behavior notes**: + - `OVERFETCH_MULT * query.limit` is passed as `$3`. Final `$4` is `query.limit`. + - Empty text query is allowed; the `fts` CTE returns zero rows (`p.q_text <> ''`) and the result degrades to pure vector search, which matches `vector_search` behavior. + - Null embedding is allowed; the `vec` CTE returns zero rows and the result degrades to pure FTS, which matches `fts_search` behavior. + - `fts_search` and `vector_search` are separate public methods on the trait. Each uses a simpler single-CTE query derived from the above by removing the other branch. Implementing them as thin wrappers over `rrf_search` with nullified inputs is acceptable but adds one extra plan per call; the explicit implementations win on latency. + - `min_retrievability` in `SearchQuery` is applied as a final filter by joining on `scheduling` in the outer `SELECT`. Adding that join unconditionally regresses simple searches; add it only when `query.min_retrievability.is_some()`. + +### D6. `embedding_model` registry impl + +- **File**: `crates/vestige-core/src/storage/postgres/registry.rs` +- **Depends on**: D1, D4 (table exists), Phase 1 `EmbeddingModelRegistry` trait. +- **Signatures**: + +```rust +#![cfg(feature = "postgres-backend")] + +use sqlx::PgPool; + +use crate::embedder::Embedder; +use crate::storage::error::{StoreError, StoreResult}; + +pub(crate) async fn ensure_registry( + pool: &PgPool, + embedder: &dyn Embedder, +) -> StoreResult<()> { + let row = sqlx::query!( + r#"SELECT name, dimension, hash FROM embedding_model WHERE id = 1"# + ) + .fetch_optional(pool) + .await?; + + match row { + None => { + sqlx::query!( + r#" + INSERT INTO embedding_model (id, name, dimension, hash) + VALUES (1, $1, $2, $3) + "#, + embedder.model_name(), + embedder.dimension() as i32, + embedder.model_hash(), + ) + .execute(pool) + .await?; + + // First-ever run: stamp the vector column typmod. + let ddl = format!( + "ALTER TABLE memories ALTER COLUMN embedding TYPE vector({})", + embedder.dimension() + ); + sqlx::query(&ddl).execute(pool).await?; + Ok(()) + } + Some(r) if r.name == embedder.model_name() + && r.dimension == embedder.dimension() as i32 + && r.hash == embedder.model_hash() => Ok(()), + Some(r) => Err(StoreError::EmbeddingMismatch { + expected: format!("{} ({}d, {})", r.name, r.dimension, r.hash), + got: format!( + "{} ({}d, {})", + embedder.model_name(), + embedder.dimension(), + embedder.model_hash() + ), + }), + } +} + +pub(crate) async fn update_registry( + pool: &PgPool, + embedder: &dyn Embedder, +) -> StoreResult<()> { + // Used only by `vestige migrate --reembed` after a full re-encode. + sqlx::query!( + r#" + UPDATE embedding_model + SET name = $1, dimension = $2, hash = $3, created_at = now() + WHERE id = 1 + "#, + embedder.model_name(), + embedder.dimension() as i32, + embedder.model_hash(), + ) + .execute(pool) + .await?; + Ok(()) +} +``` + +- **Behavior notes**: + - `StoreError::EmbeddingMismatch { expected, got }` already exists in Phase 1; Phase 2 just constructs it. + - The `ALTER TABLE ... TYPE vector(N)` DDL is only issued on first init. On subsequent inits the existing typmod already matches. + - Re-embed flow also uses this module, but the DDL path is different -- see D11. + +### D7. `VestigeConfig`: `vestige.toml` backend selection + +- **File**: `crates/vestige-core/src/config.rs` (Phase 1 may already own this file; Phase 2 extends, not replaces) +- **Depends on**: D1. +- **Signatures**: + +```rust +use std::path::{Path, PathBuf}; + +use serde::Deserialize; + +#[derive(Debug, Clone, Deserialize)] +pub struct VestigeConfig { + #[serde(default)] + pub embeddings: EmbeddingsConfig, + #[serde(default)] + pub storage: StorageConfig, + #[serde(default)] + pub server: ServerConfig, + #[serde(default)] + pub auth: AuthConfig, +} + +#[derive(Debug, Clone, Deserialize)] +pub struct EmbeddingsConfig { + pub provider: String, // "fastembed" + pub model: String, // "BAAI/bge-base-en-v1.5" +} + +#[derive(Debug, Clone, Deserialize)] +#[serde(tag = "backend", rename_all = "lowercase")] +pub enum StorageConfig { + Sqlite(SqliteConfig), + #[cfg(feature = "postgres-backend")] + Postgres(PostgresConfig), +} + +#[derive(Debug, Clone, Deserialize)] +pub struct SqliteConfig { + pub path: PathBuf, +} + +#[cfg(feature = "postgres-backend")] +#[derive(Debug, Clone, Deserialize)] +pub struct PostgresConfig { + pub url: String, + #[serde(default)] + pub max_connections: Option, + #[serde(default)] + pub acquire_timeout_secs: Option, +} + +#[derive(Debug, Clone, Default, Deserialize)] +pub struct ServerConfig { /* Phase 3 fills this in */ } + +#[derive(Debug, Clone, Default, Deserialize)] +pub struct AuthConfig { /* Phase 3 fills this in */ } + +impl VestigeConfig { + pub fn load(path: Option<&Path>) -> Result; + pub fn default_path() -> PathBuf; // ~/.vestige/vestige.toml +} + +#[derive(Debug, thiserror::Error)] +pub enum ConfigError { + #[error("io: {0}")] + Io(#[from] std::io::Error), + #[error("toml: {0}")] + Toml(#[from] toml::de::Error), + #[error("invalid config: {0}")] + Invalid(String), +} +``` + +- **Behavior notes**: + - The serde representation matches the PRD: `[storage]` with `backend = "sqlite"` and a matching `[storage.sqlite]` or `[storage.postgres]` subsection. + - Because `StorageConfig` is `#[serde(tag = "backend")]`, an unknown backend string returns a clear error. + - If `postgres-backend` is compiled off and the user writes `backend = "postgres"`, deserialization returns "unknown variant `postgres`" -- loud failure. Phase 2 wraps this into `ConfigError::Invalid("postgres-backend feature not compiled in")`. + - `env`-override hooks (e.g., `VESTIGE_POSTGRES_URL`) are a Phase 3 concern; not added here. + +### D8. `vestige migrate --from sqlite --to postgres` + +- **File**: `crates/vestige-core/src/storage/postgres/migrate_cli.rs` +- **Depends on**: D2, D6, D7, Phase 1 `SqliteMemoryStore`. +- **Signatures**: + +```rust +#![cfg(feature = "postgres-backend")] + +use std::path::Path; +use std::sync::Arc; + +use futures::{StreamExt, TryStreamExt}; +use indicatif::{ProgressBar, ProgressStyle}; +use uuid::Uuid; + +use crate::embedder::Embedder; +use crate::storage::error::{StoreError, StoreResult}; +use crate::storage::postgres::PgMemoryStore; +use crate::storage::sqlite::SqliteMemoryStore; + +#[derive(Debug, Clone)] +pub struct SqliteToPostgresPlan { + pub sqlite_path: std::path::PathBuf, + pub postgres_url: String, + pub max_connections: u32, + pub batch_size: usize, // default 500 +} + +pub struct MigrationReport { + pub memories_copied: u64, + pub scheduling_rows: u64, + pub edges_copied: u64, + pub review_events_copied: u64, + pub domains_copied: u64, + pub errors: Vec<(Uuid, StoreError)>, +} + +pub async fn run_sqlite_to_postgres( + plan: SqliteToPostgresPlan, + embedder: Arc, +) -> StoreResult; +``` + +Algorithm: + +1. Open source `SqliteMemoryStore` in read-only mode (`?mode=ro`). +2. Check source `embedding_model` registry; refuse if it disagrees with the supplied embedder unless the user also passed `--reembed`. +3. Open destination `PgMemoryStore` via `connect` (runs migrations, stamps dim). +4. Stream source rows in batches of `plan.batch_size` via a windowed query ordered by `created_at, id` (stable cursor; survives resume). +5. For each batch: begin a Postgres transaction, `INSERT INTO memories ... ON CONFLICT (id) DO NOTHING` for all rows, `INSERT INTO scheduling` likewise, commit. Copy domain assignments (`domains`, `domain_scores`) verbatim -- they are `[]` and `{}` for pre-Phase-4 SQLite data. +6. After memories finish, stream edges and review_events the same way. +7. Emit progress via `indicatif::ProgressBar` (one bar per table, multi-bar). Each 1000 rows log to tracing at INFO. +8. Return `MigrationReport` for the caller to print. + +- **Behavior notes**: + - Memory-bounded: batch size 500 and sqlx streams mean memory usage stays O(batch * row_size), not O(total_rows). + - Idempotent: re-running replays only the rows not already present; `ON CONFLICT DO NOTHING` means partial runs recover. + - UUID strings from SQLite are parsed via `Uuid::parse_str` -- any mangled ID pushes to `errors` instead of aborting. + - The FTS `search_vec` is regenerated by Postgres via the GENERATED column; no data to copy. + - `review_events` may not exist in Phase 1 SQLite for pre-V12 databases. The migrator detects missing tables via `SELECT name FROM sqlite_master` and skips gracefully. + - A separate `--dry-run` flag prints the counts per table without writing. + +### D9. `vestige migrate --reembed --model=` + +- **File**: `crates/vestige-core/src/storage/postgres/reembed.rs` +- **Depends on**: D2, D6, Phase 1 `Embedder`. +- **Signatures**: + +```rust +#![cfg(feature = "postgres-backend")] + +use std::sync::Arc; +use std::time::Instant; + +use futures::TryStreamExt; +use indicatif::{ProgressBar, ProgressStyle}; +use sqlx::PgPool; +use uuid::Uuid; + +use crate::embedder::Embedder; +use crate::storage::error::{StoreError, StoreResult}; +use crate::storage::postgres::PgMemoryStore; + +#[derive(Debug, Clone)] +pub struct ReembedPlan { + pub batch_size: usize, // default 128 (embedder batch) + pub drop_hnsw_first: bool, // default true + pub concurrent_index: bool, // default false; use CREATE INDEX (not CONCURRENTLY) +} + +pub struct ReembedReport { + pub rows_updated: u64, + pub duration_secs: f64, + pub index_rebuild_secs: f64, +} + +pub async fn run_reembed( + store: &PgMemoryStore, + new_embedder: Arc, + plan: ReembedPlan, +) -> StoreResult; +``` + +Algorithm: + +1. Verify `new_embedder.dimension()` != stored dimension OR `new_embedder.model_hash()` != stored hash -- otherwise no-op and return `rows_updated = 0`. +2. `BEGIN; ALTER TABLE memories ALTER COLUMN embedding DROP NOT NULL`; not actually needed (column is already nullable) but shown here for documentation. +3. If `plan.drop_hnsw_first`, execute `DROP INDEX IF EXISTS idx_memories_embedding_hnsw;` so updates are not slowed by index maintenance. This is the recommended path; `REINDEX` is kept in the Open Questions as an alternative. +4. Stream all `id, content` from `memories` ordered by `id`. +5. For each batch of `plan.batch_size`: call `new_embedder.embed_batch(&texts)` (Phase 1 trait exposes batched embedding when available; otherwise loop single `embed`). Then: + +```sql +UPDATE memories +SET embedding = v.embedding::vector +FROM UNNEST($1::uuid[], $2::real[][]) AS v(id, embedding) +WHERE memories.id = v.id; +``` + +6. After all rows updated: run `ALTER TABLE memories ALTER COLUMN embedding TYPE vector($NEW_DIM)` if dimension changed. +7. Rebuild HNSW. If `plan.concurrent_index`, execute `CREATE INDEX CONCURRENTLY idx_memories_embedding_hnsw ...`; else `CREATE INDEX idx_memories_embedding_hnsw ...`. +8. `update_registry` with the new embedder. +9. Return `ReembedReport`. + +- **Behavior notes**: + - Memory-bounded: batch_size * 2 (old + new texts) vectors in RAM at any time. + - The dimension change must happen AFTER all rows are updated (pgvector validates typmod on write when a typmod is present; we relax-then-tighten). + - `CONCURRENTLY` builds do not hold `AccessExclusiveLock`, but fail inside a transaction. That's why the outer driver runs index DDL as an autocommit statement (sqlx `execute` outside a pool transaction). + - For `--dry-run`, emit what *would* happen (row count, estimated embedder calls, estimated time using `rows / 50`-per-second baseline for local fastembed) and exit. + +### D10. CLI wiring in `vestige-mcp` + +- **File**: `crates/vestige-mcp/src/bin/cli.rs` +- **Depends on**: D8, D9, D7. Requires `vestige-mcp` Cargo feature `postgres-backend`. +- **Signatures**: + +```rust +#[derive(Subcommand)] +enum Commands { + // existing variants: Stats, Health, Consolidate, Restore, Backup, + // Export, Gc, Dashboard, Ingest, Serve ... + + /// Migrate between backends or re-embed memories. + #[cfg(feature = "postgres-backend")] + Migrate(MigrateArgs), +} + +#[derive(clap::Args)] +#[cfg(feature = "postgres-backend")] +struct MigrateArgs { + #[command(subcommand)] + action: MigrateAction, +} + +#[derive(Subcommand)] +#[cfg(feature = "postgres-backend")] +enum MigrateAction { + /// Copy all memories from SQLite to Postgres. + #[command(name = "copy")] + Copy { + #[arg(long)] + from: String, // "sqlite" + #[arg(long)] + to: String, // "postgres" + #[arg(long)] + sqlite_path: PathBuf, + #[arg(long)] + postgres_url: String, + #[arg(long, default_value = "500")] + batch_size: usize, + #[arg(long)] + dry_run: bool, + }, + /// Re-embed all memories with a new embedder. + #[command(name = "reembed")] + Reembed { + #[arg(long)] + model: String, + #[arg(long, default_value = "128")] + batch_size: usize, + #[arg(long, default_value_t = true)] + drop_hnsw_first: bool, + #[arg(long)] + concurrent_index: bool, + #[arg(long)] + dry_run: bool, + }, +} +``` + +The user-facing invocation collapses to the exact string requested by the ADR: + +``` +vestige migrate copy --from sqlite --to postgres \ + --sqlite-path ~/.vestige/vestige.db \ + --postgres-url postgresql://localhost/vestige + +vestige migrate reembed --model=BAAI/bge-large-en-v1.5 +``` + +An alternate top-level layout (single `vestige migrate` with flags `--from`, `--to`, `--reembed`) is equivalent; the subcommand split is preferred because the two flag sets are disjoint (see Open Question 1). + +- **Behavior notes**: + - `--from`/`--to` values are validated; the current Phase 2 build accepts only `sqlite` and `postgres`. + - For `reembed`, the `--model` string resolves to an `Embedder` via a factory already provided by Phase 1 (`Embedder::from_name(&str)`); Phase 2 does not invent new embedder constructors. + - Progress output on `stderr`; machine-readable summary on `stdout` as one-line JSON when `--json` is set (skipped for Phase 2 unless trivial). + +### D11. Offline query cache (`.sqlx/`) + +- **File**: `crates/vestige-core/.sqlx/` (committed directory of `query-*.json`) +- **Depends on**: all `sqlx::query!` call sites being final. +- **Procedure**: the developer runs `cargo sqlx prepare --workspace` with a live Postgres having the schema applied. Output goes into `crates/vestige-core/.sqlx/`. This directory is committed. CI enforces freshness by running `cargo sqlx prepare --workspace --check` against the same live Postgres (or failing that, any dev can reproduce by setting `SQLX_OFFLINE=true`). +- **Behavior notes**: `SQLX_OFFLINE=true` in `build.rs` or env is the default on CI and for downstream consumers. The `vestige-core` docs add a one-liner in README for contributors: "if you change any SQL in Phase 2 modules, rerun `cargo sqlx prepare` with a live DB." + +### D12. Testcontainer harness (integration) + +- **File**: `tests/phase_2/common/mod.rs` (the `common` convention used in `tests/phase_2/` crates) +- **Depends on**: D2 through D11. +- **Signatures**: + +```rust +#![cfg(feature = "postgres-backend")] + +use std::sync::Arc; + +use testcontainers_modules::postgres::Postgres; +use testcontainers::{runners::AsyncRunner, ContainerAsync}; + +use vestige_core::embedder::Embedder; +use vestige_core::storage::postgres::PgMemoryStore; + +pub struct PgHarness { + pub container: ContainerAsync, + pub store: PgMemoryStore, +} + +impl PgHarness { + pub async fn start(embedder: Arc) -> anyhow::Result { + let container = Postgres::default() + .with_tag("pg16") + .with_name("pgvector/pgvector") + .start() + .await?; + let port = container.get_host_port_ipv4(5432).await?; + let url = format!( + "postgresql://postgres:postgres@127.0.0.1:{}/postgres", port + ); + let store = PgMemoryStore::connect(&url, 4, embedder.as_ref()).await?; + Ok(Self { container, store }) + } +} +``` + +- **Behavior notes**: + - Image `pgvector/pgvector:pg16` bundles pgvector into the official postgres:16 image. + - Pool size 4 is enough for tests without starving the container's default `max_connections = 100`. + - `ContainerAsync` is held for the whole test scope; drop tears down the container. + - A fake `TestEmbedder` in `common/test_embedder.rs` provides a deterministic hash-based embedding (no ONNX dependency in CI). + +--- + +## Test Plan + +### Unit tests (colocated in `src/`) + +Under `crates/vestige-core/src/storage/postgres/`: + +- `pool.rs` -- one test per `build_pool` branch: defaults, explicit `max_connections`, invalid URL returns `StoreError::Postgres`. +- `registry.rs` -- three tests: first-init writes row and alters typmod, reopen with same embedder returns Ok, reopen with different dimension returns `EmbeddingMismatch`. +- `search.rs` -- query-builder unit tests for parameter packing: empty text, null embedding, all three filters null, all three filters populated. +- `migrate_cli.rs` -- `SqliteToPostgresPlan::default` returns sane defaults; plan validation rejects empty URL. +- `reembed.rs` -- `ReembedPlan::no_change` returns `rows_updated == 0` when embedder matches registry (no network call). +- `config.rs` -- five tests covering: valid postgres config, valid sqlite config, unknown backend string, missing subsection, feature-gated postgres without feature compiled in. + +### Integration tests (in `tests/phase_2/`) + +Each file is a full integration test crate (`[[test]]` in workspace root Cargo). + +**`tests/phase_2/pg_trait_parity.rs`** + +- Declares the same test matrix as Phase 1's SQLite trait tests, parameterized over `impl MemoryStore`. +- Runs every method: `insert`, `get`, `update`, `delete`, `search`, `fts_search`, `vector_search`, `get_scheduling`, `update_scheduling`, `get_due_memories`, `add_edge`, `get_edges`, `remove_edge`, `get_neighbors`, `list_domains`, `get_domain`, `upsert_domain`, `delete_domain`, `classify`, `count`, `get_stats`, `vacuum`, `health_check`. +- Each test is written once as `async fn roundtrip_(store: &dyn MemoryStore)` and invoked from two wrappers, one for SQLite and one for Postgres. +- Acceptance: every method returns equal results (except for `Uuid` ordering in `list_domains` where the test sorts before comparing). + +**`tests/phase_2/pg_hybrid_search_rrf.rs`** + +- Inserts 20 memories with known content ("rust async trait", "postgres hnsw vector", "fastembed onnx model", ...). +- Case 1: pure FTS. `SearchQuery { text: Some("rust trait"), embedding: None, ... }` returns the three Rust-related rows in order; `fts_score` populated, `vector_score` null. +- Case 2: pure vector. `SearchQuery { text: None, embedding: Some(embed("rust trait")), ... }` returns the same three rows via cosine; `vector_score` populated, `fts_score` null. +- Case 3: hybrid. Both set -- top hit has both scores; `rrf_score >= 1/(60+1) + 1/(60+1) = 0.0328`. +- Case 4: domain filter. 10 memories tagged with `domains = ["dev"]`, 10 with `["home"]`. Query with `domains: Some(vec!["dev"])` returns only dev memories. +- Case 5: edge case -- empty FTS query plus an embedding behaves identically to `vector_search`; empty embedding plus FTS query behaves identically to `fts_search`. + +**`tests/phase_2/pg_migration_sqlite_to_postgres.rs`** + +- Populate a fresh SQLite with 10,000 memories (seeded RNG, deterministic content), 4,000 scheduling rows, 2,000 edges. +- Run `run_sqlite_to_postgres` with a test embedder. +- Assert: `count() == 10_000` on destination; spot-check 25 memories byte-for-byte (content, tags, metadata, domains, domain_scores). +- Assert: FSRS fields (`stability`, `difficulty`, `next_review`) preserved per memory. +- Assert: edges preserved by `(source_id, target_id, edge_type)`. +- Assert: re-running the migration is a no-op (`ON CONFLICT DO NOTHING` path); row count unchanged. + +**`tests/phase_2/pg_migration_reembed.rs`** + +- Start with a fresh store using `TestEmbedder768` (768-dim, hash `h1`). Insert 500 memories. +- Swap to `TestEmbedder1024` (1024-dim, hash `h2`). Run `run_reembed(store, Arc::new(TestEmbedder1024), ReembedPlan::default())`. +- Assert: `rows_updated == 500`; `embedding_model` now has `(name=TestEmbedder1024, dimension=1024, hash=h2)`. +- Assert: `SELECT DISTINCT vector_dims(embedding) FROM memories` returns only `1024`. +- Assert: HNSW index exists after reembed (`SELECT indexrelid FROM pg_indexes WHERE indexname = 'idx_memories_embedding_hnsw'`). +- Assert: memory IDs unchanged (compare pre/post id sets). +- Assert: a hybrid search using `TestEmbedder1024` returns results (post-reembed vectors are queryable). + +**`tests/phase_2/pg_config_parsing.rs`** + +- Parse six `vestige.toml` snippets: + - sqlite + fastembed -> `StorageConfig::Sqlite`. + - postgres + fastembed -> `StorageConfig::Postgres` with `max_connections = 10`. + - postgres with custom `max_connections = 25` and `acquire_timeout_secs = 60`. + - unknown backend `"mysql"` -> `ConfigError`. + - missing subsection `[storage.postgres]` while `backend = "postgres"` -> `ConfigError`. + - malformed URL (empty) -> `ConfigError::Invalid`. + +**`tests/phase_2/pg_concurrency.rs`** + +- Spawn 16 tasks, each inserting 100 memories in parallel for 1,600 total. +- Spawn 4 tasks concurrently running `search` queries; none should fail. +- Spawn 2 tasks concurrently running `update_scheduling` on overlapping IDs -- last write wins (MVCC), neither errors. +- Assert: all 1,600 rows present, no deadlocks, every task returns `Ok`. +- Run time < 10 seconds on a cold container. + +### Compile-time query verification + +- CI step: `cargo sqlx prepare --workspace --check` against a CI-provisioned Postgres (GitHub Actions / Forgejo Actions services block). Fails CI if any `query!` macro goes stale. +- Alternative offline run for contributors: `SQLX_OFFLINE=true cargo check -p vestige-core --features postgres-backend`. CI runs both forms to ensure `.sqlx/` is up to date. +- `.sqlx/` is committed to the repo. A `.gitattributes` entry marks it as `linguist-generated=true` so it doesn't inflate language stats. + +### Benchmarks + +Under `crates/vestige-core/benches/pg_hybrid_search.rs` (Criterion), gated by `postgres-backend`. + +- `pg_search_1k` -- populate 1,000 memories once per bench suite, measure `rrf_search` p50/p99 over 500 iterations. Target: p50 < 10ms, p99 < 30ms on a local container. +- `pg_search_100k` -- 100,000 memories. Target: p50 < 50ms, p99 < 150ms. Validates HNSW scaling. +- Testcontainer shared across both benches via `once_cell`. +- Bench entry in `vestige-core/Cargo.toml`: + +``` +[[bench]] +name = "pg_hybrid_search" +harness = false +required-features = ["postgres-backend"] +``` + +--- + +## Acceptance Criteria + +- [ ] `cargo build -p vestige-core --features postgres-backend` -- zero warnings. +- [ ] `cargo build -p vestige-core` (SQLite-only, default features) -- zero warnings; no Postgres symbols referenced. +- [ ] `cargo build -p vestige-mcp --features postgres-backend` -- zero warnings; `vestige` binary exposes the `migrate` subcommand. +- [ ] `cargo clippy --workspace --all-targets --all-features -- -D warnings` -- clean. +- [ ] `cargo sqlx prepare --workspace --check` -- returns success; `.sqlx/` is current. +- [ ] `cargo test -p vestige-core --features postgres-backend --test pg_trait_parity --test pg_hybrid_search_rrf --test pg_migration_sqlite_to_postgres --test pg_migration_reembed --test pg_config_parsing --test pg_concurrency` -- all green. +- [ ] Testcontainer spin-up p50 under 30 seconds on a developer laptop with a warm Docker daemon. +- [ ] `pg_search_100k` Criterion bench reports p50 < 50ms on reference hardware (logged in the ADR comment trail). +- [ ] `vestige migrate copy --from sqlite --to postgres` on a 10,000-memory corpus completes without data loss: row count parity, content byte-parity on a 1 percent sample, FSRS state preserved (stability, difficulty, reps, lapses, next_review), edge count parity. +- [ ] `vestige migrate reembed` with a dimension-changing embedder returns to a fully queryable state: HNSW present, `embedding_model` updated, no stale vectors, memory IDs untouched. +- [ ] Trait parity: every method on `MemoryStore` has at least one passing test against `PgMemoryStore`. +- [ ] Phase 1's existing SQLite suite continues to pass with zero changes required (Phase 2 is additive). +- [ ] The `postgres-backend` feature does not compile in SQLCipher (`encryption`) simultaneously (mutually exclusive at compile time, per project rule). + +--- + +## Rollback Notes + +- Every `*.up.sql` has a matching `*.down.sql` in `crates/vestige-core/migrations/postgres/`. `sqlx migrate revert` walks them in reverse order. Manual operator procedure: `sqlx migrate revert --database-url $URL --source crates/vestige-core/migrations/postgres`. +- `vestige migrate copy` is a one-way operation. The source SQLite DB is read-only during the run and untouched afterward; users retain their original file indefinitely. Recommended discipline: copy the SQLite file aside before starting, retain for 30 days. +- `vestige migrate reembed` is destructive to the `embedding` column. Recommended discipline: take a logical backup (`pg_dump --table=memories --table=embedding_model --table=scheduling`) before a reembed run. The tool prints that recommendation before starting and exits non-zero unless `--yes` is passed or the user is on a TTY that confirms. +- Feature-gate strategy: the default build remains SQLite-only. Downstream users pull `postgres-backend` explicitly: `cargo install --features postgres-backend vestige-mcp`. If the Postgres implementation fails in the field, users fall back to SQLite simply by flipping `vestige.toml`'s `[storage] backend = "sqlite"` and restarting. No data re-migration is needed if they retained their SQLite file. +- The `docs/runbook/postgres.md` deliverable (D16) captures this discipline as a one-page ops note. + +--- + +## Open Implementation Questions + +Each item has a recommendation. Ship that unless a reviewer objects. + +### Q1. CLI shape: subcommand split vs flag union + +- **Options**: (a) `vestige migrate copy --from sqlite --to postgres ...` and `vestige migrate reembed --model=...` (subcommand split); (b) `vestige migrate --from sqlite --to postgres ...` and `vestige migrate --reembed --model=...` under one `clap` command with disjoint flag groups (flag union). +- **RECOMMENDATION**: (a) subcommand split. The flag sets do not overlap and clap expresses the constraint more cleanly. The ADR string `vestige migrate --from sqlite --to postgres` can still be documented as a canonical alias by having `copy` accept it verbatim when `--from` is present. + +### Q2. Feature flag name + +- **Options**: `postgres-backend`, `postgres`, `backend-postgres`, `pg`. +- **RECOMMENDATION**: `postgres-backend`. Matches the ADR text and is explicit in `Cargo.toml` feature listings. + +### Q3. sqlx offline mode strategy + +- **Options**: (a) commit `.sqlx/` so downstream builds never need DATABASE_URL; (b) require `DATABASE_URL` at build time. +- **RECOMMENDATION**: (a). The repo already ships as a library; many downstream users will build from crates.io with no Postgres available. Committing `.sqlx/` costs ~100 kB. + +### Q4. HNSW rebuild strategy during reembed + +- **Options**: (a) `DROP INDEX; CREATE INDEX`; (b) `REINDEX INDEX CONCURRENTLY`; (c) `CREATE INDEX CONCURRENTLY` on a new name then swap. +- **RECOMMENDATION**: (a) by default for speed on empty / near-empty tables; expose `--concurrent-index` for large production corpora where locking the table is unacceptable. `REINDEX CONCURRENTLY` on pgvector HNSW is supported in pgvector 0.6+ but the community still reports edge cases with `maintenance_work_mem` -- skip unless a user explicitly opts in. + +### Q5. Connection pool sizing default + +- **Options**: 4, 10, 20, `cpus() * 2`. +- **RECOMMENDATION**: 10. Matches the PRD example, covers a single-operator load, and does not exhaust the default Postgres `max_connections = 100`. Configurable via `vestige.toml`. + +### Q6. Testcontainer image pinning + +- **Options**: (a) `pgvector/pgvector:pg16`; (b) `pgvector/pgvector:pg16.2-0.7.4` (exact tag); (c) maintain local Dockerfile. +- **RECOMMENDATION**: (b) pin exact. The float tag `pg16` has shipped breaking changes in the past (e.g., pg 16.0 to 16.1 interop). Pin to a specific pgvector minor and Postgres patch. CI bumps the tag via a single-line change. + +### Q7. Empty-text and null-embedding behavior in `search` + +- **Options**: (a) return an error if both are missing; (b) return an empty result; (c) return all memories sorted by `created_at DESC`. +- **RECOMMENDATION**: (a). A `search` call with no query is a bug in the caller; returning empty silently would hide the bug. The existing Phase 1 SQLite behavior (TBD but likely errors) is the tiebreaker. + +### Q8. `classify()` SQL vs Rust + +- **Options**: (a) compute cosine to all centroids in SQL (`SELECT id, 1 - (centroid <=> $1::vector) FROM domains ORDER BY ...`); (b) load centroids, compute in Rust. +- **RECOMMENDATION**: (a). Leverages pgvector's SIMD paths and avoids round-tripping centroid vectors. At Phase 4 scale (tens of centroids) the difference is marginal, but the SQL path is simpler and matches the rest of the backend. + +### Q9. FSRS `review_events` writes: trait method vs implicit on `update_scheduling` + +- **Options**: (a) add an explicit `record_review(memory_id, rating, prior, new)` method to the Phase 1 trait; (b) have `update_scheduling` write the event atomically. +- **RECOMMENDATION**: this is a Phase 1 question, not Phase 2. Phase 2 implements whichever Phase 1 chose. If Phase 1 missed it, Phase 2 raises a blocker rather than deciding alone. + +### Q10. `tsvector` weight for tags -- PRD used `array_to_tsvector`, we used `array_to_string` + +- **Options**: (a) `array_to_tsvector(tags)` (requires the `tsvector_extra` extension or similar); (b) `to_tsvector('english', array_to_string(tags, ' '))` (plain core Postgres). +- **RECOMMENDATION**: (b). Equivalent ranking, zero extra extensions. If a future tag matches a stopword (`"the"`), it gets dropped, but that is correct behavior for ranking. + +### Q11. `PgMemoryStore::connect` runs migrations automatically? + +- **Options**: (a) always run `sqlx::migrate!` on connect; (b) require the user to run `vestige migrate-schema` explicitly before starting the server. +- **RECOMMENDATION**: (a) during Phase 2; revisit in Phase 3 when the server binary exists. Developer ergonomics win now, and the migrations are idempotent. + +### Q12. Offline query cache freshness vs `sqlx-cli` version skew + +- **Options**: (a) pin `sqlx-cli` version in CI `actions/cache` step; (b) let CI install whatever version `sqlx` depends on. +- **RECOMMENDATION**: (a) pin to the same 0.8.x as the crate. `sqlx prepare` output changes between 0.7 and 0.8 and must match the runtime. + +--- + +## Sequencing + +The Phase 2 agent executes deliverables in this order; deliverables not listed can run in any order relative to each other. + +1. D1 (feature gate + Cargo deps) -- unblocks everything. +2. D7 (config) -- required to construct `PgMemoryStore`. +3. D4 (migrations SQL) -- required before any `query!` compiles. +4. D3 (pool) + D6 (registry) -- small, used by D2. +5. D2 (`PgMemoryStore` core + trait impl) -- the bulk of Phase 2. +6. D5 (RRF search) -- after D2; requires the trait to exist. +7. D12 (test harness) + parity and search tests -- validates D2 and D5 in isolation. +8. D8 (sqlite->pg migrate) + its integration test. +9. D9 (reembed) + its integration test. +10. D10 (CLI wiring). +11. D11 (`.sqlx/` offline cache) -- last, after SQL is frozen. +12. D15 (benches) + D16 (runbook) -- after acceptance tests pass. + +Each deliverable PR includes its own tests; the final Phase 2 PR stacks them (or lands as a single branch if the Phase 1 trait is stable enough to avoid rebase churn). + +### Critical Files for Implementation + +- /home/delandtj/prppl/vestige/crates/vestige-core/src/storage/postgres/mod.rs +- /home/delandtj/prppl/vestige/crates/vestige-core/migrations/postgres/0001_init.up.sql +- /home/delandtj/prppl/vestige/crates/vestige-core/src/storage/postgres/search.rs +- /home/delandtj/prppl/vestige/crates/vestige-core/src/storage/postgres/migrate_cli.rs +- /home/delandtj/prppl/vestige/crates/vestige-mcp/src/bin/cli.rs diff --git a/docs/plans/0003-phase-3-network-access.md b/docs/plans/0003-phase-3-network-access.md new file mode 100644 index 0000000..500fd5a --- /dev/null +++ b/docs/plans/0003-phase-3-network-access.md @@ -0,0 +1,1435 @@ +# Phase 3 Plan: Network Access and Authentication + +**Status**: Draft +**Depends on**: Phase 1 (MemoryStore trait), Phase 2 (PgMemoryStore, backend config) +**Related**: docs/adr/0001-pluggable-storage-and-network-access.md (Phase 3) + +--- + +## Scope + +### In scope + +- HTTP MCP Streamable endpoint at `POST /mcp` (JSON-RPC body, keep existing + session semantics) and `GET /mcp` (Server-Sent Events for long-running + operations: dream, consolidate, discover, reassign). +- REST API under `/api/v1/` for direct HTTP clients that do not speak MCP + (memories CRUD, search, consolidate trigger, stats, domains + list/rename/merge/discover). +- `api_keys` table + enforcement (blake3-hashed, scopes `read`/`write`, optional + `domain_filter` TEXT[], `last_used` timestamp, `active` flag, revocation). +- Auth middleware with three resolution paths in priority order: + `Authorization: Bearer ` then `X-API-Key: ` then signed session + cookie. All three resolve to the same `ApiKeyIdentity`. +- Signed session cookie: `vestige_session`, SameSite=Strict, HttpOnly, + Secure-when-TLS, Path=/, Max-Age 8 hours. Signed with HMAC-SHA256 using a + key derived from `VESTIGE_SESSION_SECRET` (env) or generated + persisted to + `/session_secret` on first boot. +- `vestige keys create|list|revoke` CLI subcommand (plus `keys rotate` as a + convenience alias of `revoke` + `create`). +- Startup-time refusal to bind non-loopback with `auth.enabled = false` (hard + error, non-zero exit, stderr message, no fallback). +- Dashboard login flow: `POST /dashboard/login` with `{"api_key":"vst_..."}` + JSON body, `X-API-Key` header, or form body; sets signed cookie; returns 200 + JSON `{"ok":true}` for XHR or 303 to `/` if form. Logout at + `POST /dashboard/logout` clears cookie. +- Per-key `domain_filter` enforced inside the auth layer: if the key has + `domain_filter = ["dev","infra"]`, every handler that searches or lists sees + the filter pre-applied via a request extension. Optional + `X-Vestige-Domain: home` header may narrow further but may never escape the + key's filter. +- `[server]` and `[auth]` sections in `vestige.toml`, plus backward-compatible + env var bridges. +- `VESTIGE_AUTH_TOKEN` continues to work for one minor release as a synthetic + single-key fallback, but logs a deprecation warning. +- Per-request request IDs and structured tracing; `last_used` write-back on + successful auth. + +### Out of scope + +- Phase 4 HDBSCAN domain classifier itself. The REST surface exposes domain + endpoints but they may stub to empty results until Phase 4 lands. +- Real TLS termination. Assumed handled by a reverse proxy (nginx, Caddy, + Mycelium). An optional `tls_cert` / `tls_key` pair is documented but its + implementation may be deferred behind a `tls` Cargo feature. +- OAuth / OIDC / SSO. Future work. +- Rate limiting per key (documented in Open Questions, not implemented here). +- WebAuthn / passkey dashboard login. Future work. +- Fine-grained RBAC beyond `read` / `write` scopes. + +## Prerequisites + +Phase 1 artifacts: + +- `vestige_core::storage::MemoryStore` trait (with `Send` variant via + `trait_variant::make`). +- `Embedder` trait. +- `SqliteMemoryStore` implementing `MemoryStore`. + +Phase 2 artifacts: + +- `PgMemoryStore` implementing `MemoryStore`. +- `crates/vestige-core/migrations/postgres/` sqlx migrations; `api_keys` table + schema present but enforcement path is Phase 3's job. +- Runtime backend selection via `vestige.toml` `[storage]` section returning + an `Arc`. + +Assumed already available in workspace: + +- `axum = 0.8` (currently pinned in `crates/vestige-mcp/Cargo.toml`). +- `tower = 0.5`, `tower-http = 0.6` (`cors`, `set-header` features already on). +- `tokio`, `serde`, `serde_json`, `uuid`, `chrono`, `tracing`, + `tracing-subscriber`, `thiserror`, `anyhow`, `subtle`, `clap`, `directories`. + +New crates required (add via `cargo add -p vestige-mcp`): + +- `blake3 = "1"` -- key hashing. +- `rand = "0.9"` with `std_rng` (for key bytes; prefer `rand::rngs::OsRng`). +- `axum-extra = { version = "0.10", features = ["cookie-signed", "typed-header"] }` + -- `SignedCookieJar`, `Cookie`, `Key`. +- `hmac = "0.12"` + `sha2 = "0.10"` -- HMAC-SHA256 for the session secret + derivation (not required if `axum-extra`'s `SignedCookieJar` is used, but + retained for the pure-token-signing path). RECOMMENDATION: rely solely on + `axum-extra::extract::cookie::{Key, SignedCookieJar}`. +- `tower-http` features bump: add `trace` and `request-id`. +- `async-stream = "0.3"` -- emitting SSE events from async closures. +- `futures-util` already present -- for `Stream` adapters. +- `base64 = "0.22"` -- emitting / parsing the random bytes in the `vst_...` + prefix. Use the `URL_SAFE_NO_PAD` alphabet. +- `zeroize = "1"` (optional, recommended) -- scrub the plaintext key in RAM + after hashing. + +`cargo add` commands (do not execute here, leave to implementation): + + cargo add -p vestige-mcp blake3 rand base64 zeroize async-stream + cargo add -p vestige-mcp axum-extra --features cookie-signed,typed-header + cargo add -p vestige-mcp tower-http --features trace,request-id,cors,set-header + +JSON-RPC library: the project uses a hand-rolled `JsonRpcRequest` / +`JsonRpcResponse` pair in `crates/vestige-mcp/src/protocol/types.rs`. Keep it +in Phase 3 (no jsonrpsee migration). Streamable HTTP remains implemented as +`POST /mcp` + session header + `GET /mcp` SSE. See Open Questions for rationale. + +## Deliverables + +1. `crates/vestige-mcp/src/auth/` module (new). Houses key generation, key + verification, identity resolution, scopes, domain-filter extractor, session + key type, and error types. + +2. `crates/vestige-mcp/src/auth/keys.rs` -- key format, generation, + blake3 hashing, store-facing trait methods for list / create / revoke / + verify. + +3. `crates/vestige-mcp/src/auth/middleware.rs` -- axum `from_fn` middleware + that populates `Extension` on the request, rejects unauthenticated + requests with 401, insufficient scope with 403. + +4. `crates/vestige-mcp/src/auth/session.rs` -- `SignedCookieJar` integration, + `session_key()` loader (env or persisted file), `issue_session()` and + `revoke_session()` helpers. + +5. `crates/vestige-mcp/src/http/` module split out of `protocol/http.rs`: + - `http/mcp.rs` -- MCP JSON-RPC endpoint (adapted from the current + `post_mcp` / `delete_mcp`, with auth middleware now gating). + - `http/mcp_sse.rs` -- SSE handler for `GET /mcp` long-running ops. + - `http/rest.rs` -- `/api/v1/*` handlers. + - `http/mod.rs` -- `build_router()`, `start_server()`, bind-safety check, + layer stack assembly. + +6. `crates/vestige-mcp/src/http/errors.rs` -- uniform `ApiError` enum and + `IntoResponse` implementation. Maps to RFC 7807 problem+json for REST and + plain JSON for `/mcp`. + +7. Dashboard patch: `crates/vestige-mcp/src/dashboard/mod.rs` -- add the auth + middleware to the dashboard router, add `/dashboard/login` + `/dashboard/logout` + endpoints, keep `/api/health` unauthenticated. + +8. `crates/vestige-mcp/src/bin/cli.rs` -- new `Keys` subcommand group (`create`, + `list`, `revoke`, `rotate`). + +9. `crates/vestige-mcp/src/config.rs` (new file) -- typed `ServerConfig`, + `AuthConfig`, `StorageConfig` loader from `vestige.toml`, merging env var + overrides, validating the non-loopback + auth-disabled combination. + +10. SQL migration `crates/vestige-core/migrations/postgres/0300_api_keys_enforcement.sql` + and SQLite equivalent `crates/vestige-core/migrations/sqlite/0300_api_keys.sql`: + - `api_keys` table (if not already created in Phase 2), with `key_hash` + UNIQUE, `label` NOT NULL, `scopes` TEXT[] default `{read,write}`, + `domain_filter` TEXT[] default `{}`, `created_at`, `last_used`, + `active BOOLEAN DEFAULT true`. + - Index on `key_hash` (unique already), and on `active WHERE active`. + +11. `MemoryStore` trait extension (Phase 2 may already cover this; if not, + finalize in Phase 3): `list_api_keys`, `create_api_key`, + `revoke_api_key`, `find_api_key_by_hash`, `touch_api_key_last_used`. + +12. Docs updates: + - `docs/env-vars.md` (new) -- one sheet for all runtime env vars. + - `README.md` server-mode section. + - `docs/adr/0001-*.md` -- mark Phase 3 as Implemented when merged. + +## Detailed Task Breakdown + +### D1. Auth module skeleton + +Files: + +- `crates/vestige-mcp/src/auth/mod.rs` +- `crates/vestige-mcp/src/auth/keys.rs` +- `crates/vestige-mcp/src/auth/session.rs` +- `crates/vestige-mcp/src/auth/middleware.rs` +- `crates/vestige-mcp/src/auth/errors.rs` + +`auth/mod.rs`: + + pub mod errors; + pub mod keys; + pub mod middleware; + pub mod session; + + pub use errors::AuthError; + pub use keys::{ApiKey, ApiKeyPlaintext, ApiKeyRecord, Scope}; + pub use middleware::{Identity, auth_layer}; + pub use session::{SessionConfig, session_key}; + +`auth/errors.rs`: + + use axum::http::StatusCode; + use axum::response::{IntoResponse, Response}; + use serde::Serialize; + use thiserror::Error; + + #[derive(Debug, Error)] + pub enum AuthError { + #[error("missing credentials")] + MissingCredentials, + #[error("invalid credentials")] + InvalidCredentials, + #[error("key revoked")] + Revoked, + #[error("insufficient scope: required {required}")] + InsufficientScope { required: &'static str }, + #[error("domain not permitted for this key: {domain}")] + DomainNotAllowed { domain: String }, + #[error("internal auth error")] + Internal, + } + + #[derive(Serialize)] + struct Problem<'a> { + #[serde(rename = "type")] + kind: &'a str, + title: &'a str, + status: u16, + detail: &'a str, + } + + impl IntoResponse for AuthError { + fn into_response(self) -> Response { + let (status, title) = match self { + AuthError::MissingCredentials => (StatusCode::UNAUTHORIZED, "unauthorized"), + AuthError::InvalidCredentials => (StatusCode::UNAUTHORIZED, "unauthorized"), + AuthError::Revoked => (StatusCode::UNAUTHORIZED, "unauthorized"), + AuthError::InsufficientScope { .. } => (StatusCode::FORBIDDEN, "forbidden"), + AuthError::DomainNotAllowed { .. } => (StatusCode::FORBIDDEN, "forbidden"), + AuthError::Internal => (StatusCode::INTERNAL_SERVER_ERROR, "internal"), + }; + let detail = self.to_string(); + let body = axum::Json(Problem { + kind: "about:blank", + title, + status: status.as_u16(), + detail: &detail, + }); + let mut r = (status, body).into_response(); + r.headers_mut().insert( + axum::http::header::CONTENT_TYPE, + axum::http::HeaderValue::from_static("application/problem+json"), + ); + r + } + } + +### D2. Key format and generation + +File: `crates/vestige-mcp/src/auth/keys.rs` + +- Key on wire: `vst_<22-byte base64url-no-pad>`. 22 bytes = 176 bits entropy. + Encoded length ~30 chars. Full string ~34 chars including the `vst_` prefix. +- Hash stored in DB: `blake3(key_plaintext)` hex lowercase (32 bytes -> 64 + hex chars). +- Hash prefix on list: first 12 hex characters, e.g. `key_hash[..12]` for + human display. + +Signatures: + + use blake3::Hasher; + use rand::rngs::OsRng; + use rand::TryRngCore; + use base64::engine::general_purpose::URL_SAFE_NO_PAD; + use base64::Engine; + use zeroize::Zeroize; + + const KEY_PREFIX: &str = "vst_"; + const KEY_RANDOM_BYTES: usize = 22; + + #[derive(Clone, Debug, PartialEq, Eq)] + pub enum Scope { + Read, + Write, + } + + impl Scope { + pub fn as_str(&self) -> &'static str { + match self { + Scope::Read => "read", + Scope::Write => "write", + } + } + pub fn from_str(s: &str) -> Option { + match s { + "read" => Some(Scope::Read), + "write" => Some(Scope::Write), + _ => None, + } + } + } + + /// The plaintext key. Shown to the user exactly once. + /// Zeroed on drop. + pub struct ApiKeyPlaintext(String); + + impl ApiKeyPlaintext { + pub fn as_str(&self) -> &str { &self.0 } + pub fn into_inner(mut self) -> String { + std::mem::take(&mut self.0) + } + } + + impl Drop for ApiKeyPlaintext { + fn drop(&mut self) { self.0.zeroize(); } + } + + #[derive(Clone, Debug)] + pub struct ApiKeyRecord { + pub id: uuid::Uuid, + pub key_hash: String, // hex-encoded blake3(plaintext) + pub label: String, + pub scopes: Vec, + pub domain_filter: Vec, + pub created_at: chrono::DateTime, + pub last_used: Option>, + pub active: bool, + } + + pub fn generate_key() -> ApiKeyPlaintext { + let mut bytes = [0u8; KEY_RANDOM_BYTES]; + OsRng.try_fill_bytes(&mut bytes).expect("OsRng"); + let encoded = URL_SAFE_NO_PAD.encode(&bytes); + bytes.zeroize(); + ApiKeyPlaintext(format!("{}{}", KEY_PREFIX, encoded)) + } + + pub fn hash_key(plaintext: &str) -> String { + let mut hasher = Hasher::new(); + hasher.update(plaintext.as_bytes()); + hasher.finalize().to_hex().to_string() + } + + pub fn verify_key(plaintext: &str, stored_hash_hex: &str) -> bool { + use subtle::ConstantTimeEq; + let computed = hash_key(plaintext); + computed.as_bytes().ct_eq(stored_hash_hex.as_bytes()).unwrap_u8() == 1 + } + +Helpers on a thin repository trait that both backends implement through +`MemoryStore` (Phase 2 already adds the required columns; Phase 3 wires the +methods): + + #[async_trait::async_trait] + pub trait ApiKeyStore: Send + Sync + 'static { + async fn create_api_key(&self, rec: &ApiKeyRecord) -> anyhow::Result<()>; + async fn find_api_key_by_hash(&self, hash: &str) -> anyhow::Result>; + async fn list_api_keys(&self) -> anyhow::Result>; + async fn revoke_api_key(&self, id: uuid::Uuid) -> anyhow::Result; + async fn touch_api_key_last_used(&self, id: uuid::Uuid) -> anyhow::Result<()>; + } + +(If Phase 2 already bolted these onto `MemoryStore`, `ApiKeyStore` is simply a +re-export of the relevant subset.) + +### D3. Session cookie + +File: `crates/vestige-mcp/src/auth/session.rs` + +- Cookie name: `vestige_session`. +- Cookie attributes: `HttpOnly`, `SameSite=Strict`, `Path=/`, `Max-Age=28800` + (8h), `Secure` when the server is running behind TLS (detected from + `config.server.tls_cert.is_some()` or the `X-Forwarded-Proto` trusted header; + default: set `Secure` whenever `config.server.bind` is non-loopback). +- Payload: serialized `SessionClaims { key_id: Uuid, issued_at: i64, + expires_at: i64 }` encoded as `serde_json` then base64url. The signing is + handled by `axum-extra::extract::cookie::SignedCookieJar` (HMAC via a 64-byte + `Key`). Any tampering or truncation is rejected by the jar automatically. +- Key material: 64 random bytes, stored at `/session_secret` (mode + 0600) or overridden by `VESTIGE_SESSION_SECRET` (base64url-encoded 64 bytes, + reject if shorter). + +Signatures: + + use axum_extra::extract::cookie::{Cookie, Key, SameSite, SignedCookieJar}; + use chrono::{Duration, Utc}; + use serde::{Deserialize, Serialize}; + + const COOKIE_NAME: &str = "vestige_session"; + const DEFAULT_TTL: Duration = Duration::hours(8); + + #[derive(Clone, Serialize, Deserialize)] + pub struct SessionClaims { + pub key_id: uuid::Uuid, + pub iat: i64, + pub exp: i64, + } + + pub fn session_key(data_dir: &std::path::Path) -> anyhow::Result { + // 1) env override + if let Ok(env_val) = std::env::var("VESTIGE_SESSION_SECRET") { + let raw = base64::engine::general_purpose::URL_SAFE_NO_PAD + .decode(env_val.trim())?; + anyhow::ensure!(raw.len() >= 64, "VESTIGE_SESSION_SECRET must be >= 64 bytes"); + return Ok(Key::from(&raw)); + } + // 2) persisted file + let path = data_dir.join("session_secret"); + if path.exists() { + let bytes = std::fs::read(&path)?; + return Ok(Key::from(&bytes)); + } + // 3) generate + use rand::TryRngCore; + let mut bytes = [0u8; 64]; + rand::rngs::OsRng.try_fill_bytes(&mut bytes)?; + #[cfg(unix)] + { + use std::io::Write; + use std::os::unix::fs::OpenOptionsExt; + std::fs::create_dir_all(data_dir).ok(); + let mut f = std::fs::OpenOptions::new() + .create_new(true).write(true).mode(0o600).open(&path)?; + f.write_all(&bytes)?; + f.sync_all()?; + } + #[cfg(not(unix))] + std::fs::write(&path, &bytes)?; + Ok(Key::from(&bytes)) + } + + pub fn issue_session( + jar: SignedCookieJar, + key_id: uuid::Uuid, + secure: bool, + ) -> SignedCookieJar { + let now = Utc::now(); + let claims = SessionClaims { + key_id, + iat: now.timestamp(), + exp: (now + DEFAULT_TTL).timestamp(), + }; + let value = serde_json::to_string(&claims).expect("serialize claims"); + let mut cookie = Cookie::new(COOKIE_NAME, value); + cookie.set_http_only(true); + cookie.set_same_site(SameSite::Strict); + cookie.set_path("/"); + cookie.set_max_age(cookie::time::Duration::seconds(DEFAULT_TTL.num_seconds())); + cookie.set_secure(secure); + jar.add(cookie) + } + + pub fn revoke_session(jar: SignedCookieJar) -> SignedCookieJar { + jar.remove(Cookie::from(COOKIE_NAME)) + } + + pub fn claims_from(jar: &SignedCookieJar) -> Option { + let c = jar.get(COOKIE_NAME)?; + let claims: SessionClaims = serde_json::from_str(c.value()).ok()?; + if claims.exp < Utc::now().timestamp() { return None; } + Some(claims) + } + +### D4. Auth middleware + +File: `crates/vestige-mcp/src/auth/middleware.rs` + +Identity carried through the request: + + #[derive(Clone, Debug)] + pub struct Identity { + pub key_id: uuid::Uuid, + pub label: String, + pub scopes: Vec, + pub domain_filter: Vec, + pub via: AuthVia, + } + + #[derive(Clone, Copy, Debug)] + pub enum AuthVia { + Bearer, + ApiKeyHeader, + SessionCookie, + } + +Middleware (axum 0.8): + + use axum::extract::{Request, State}; + use axum::http::{header, StatusCode}; + use axum::middleware::Next; + use axum::response::{IntoResponse, Response}; + use axum_extra::extract::cookie::SignedCookieJar; + use std::sync::Arc; + + pub async fn auth_layer( + State(state): State>, + jar: SignedCookieJar, + mut request: Request, + next: Next, + ) -> Response { + // Allowlist endpoints that never require auth: + let path = request.uri().path(); + if path == "/api/health" || path == "/api/v1/health" || + path == "/dashboard/login" { + return next.run(request).await; + } + + let via_and_key = extract_credentials(request.headers(), &jar); + let outcome = match via_and_key { + Some((AuthVia::Bearer, key)) | Some((AuthVia::ApiKeyHeader, key)) => { + resolve_by_plaintext(&state, &key).await.map(|id| (id, via_and_key.unwrap().0)) + } + Some((AuthVia::SessionCookie, key_id_str)) => { + let id = uuid::Uuid::parse_str(&key_id_str).map_err(|_| AuthError::InvalidCredentials)?; + resolve_by_key_id(&state, id).await.map(|id| (id, AuthVia::SessionCookie)) + } + None => Err(AuthError::MissingCredentials), + }; + + let identity = match outcome { + Ok((id, via)) => Identity { via, ..id }, + Err(e) => return e.into_response(), + }; + + // touch last_used asynchronously; do not block request path + let st2 = state.clone(); + let kid = identity.key_id; + tokio::spawn(async move { let _ = st2.store.touch_api_key_last_used(kid).await; }); + + request.extensions_mut().insert(identity); + next.run(request).await + } + +Credential extraction (priority: Bearer > X-API-Key > cookie): + + fn extract_credentials( + headers: &axum::http::HeaderMap, + jar: &SignedCookieJar, + ) -> Option<(AuthVia, String)> { + if let Some(v) = headers.get(header::AUTHORIZATION).and_then(|h| h.to_str().ok()) { + if let Some(rest) = v.strip_prefix("Bearer ") { + return Some((AuthVia::Bearer, rest.trim().to_string())); + } + } + if let Some(v) = headers.get("x-api-key").and_then(|h| h.to_str().ok()) { + return Some((AuthVia::ApiKeyHeader, v.trim().to_string())); + } + if let Some(claims) = crate::auth::session::claims_from(jar) { + return Some((AuthVia::SessionCookie, claims.key_id.to_string())); + } + None + } + +Resolution helpers: + + async fn resolve_by_plaintext(st: &AppCtx, key: &str) -> Result { + let hash = crate::auth::keys::hash_key(key); + let rec = st.store.find_api_key_by_hash(&hash).await + .map_err(|_| AuthError::Internal)? + .ok_or(AuthError::InvalidCredentials)?; + if !rec.active { return Err(AuthError::Revoked); } + Ok(Identity { + key_id: rec.id, label: rec.label, scopes: rec.scopes, + domain_filter: rec.domain_filter, via: AuthVia::Bearer, + }) + } + + async fn resolve_by_key_id(st: &AppCtx, id: uuid::Uuid) -> Result { + let rec = st.store.find_api_key_by_id(id).await + .map_err(|_| AuthError::Internal)? + .ok_or(AuthError::InvalidCredentials)?; + if !rec.active { return Err(AuthError::Revoked); } + Ok(Identity { + key_id: rec.id, label: rec.label, scopes: rec.scopes, + domain_filter: rec.domain_filter, via: AuthVia::SessionCookie, + }) + } + +Scope guard extractor (per-handler opt-in): + + pub struct RequireScope; + impl axum::extract::FromRequestParts for RequireScope + where S: Send + Sync, + { + type Rejection = AuthError; + async fn from_request_parts( + parts: &mut axum::http::request::Parts, _state: &S, + ) -> Result { + let id = parts.extensions.get::().ok_or(AuthError::MissingCredentials)?; + let need = if WRITE { Scope::Write } else { Scope::Read }; + if !id.scopes.contains(&need) { + return Err(AuthError::InsufficientScope { + required: if WRITE { "write" } else { "read" }, + }); + } + Ok(RequireScope) + } + } + +Domain scoping: + + /// Returns the effective domain filter for the request: + /// - Intersect the key's domain_filter with any X-Vestige-Domain header. + /// - Empty key filter means "all domains", so the header is authoritative. + /// - A header that names a domain outside the key filter returns + /// `Err(DomainNotAllowed)`. + pub fn effective_domain_filter( + id: &Identity, header: Option<&str>, + ) -> Result>, AuthError> { + let header_dom = header.map(|s| s.trim().to_string()).filter(|s| !s.is_empty()); + match (id.domain_filter.as_slice(), header_dom) { + ([], None) => Ok(None), + ([], Some(h)) => Ok(Some(vec![h])), + (filter, None) => Ok(Some(filter.to_vec())), + (filter, Some(h)) => { + if filter.iter().any(|d| d == &h) { + Ok(Some(vec![h])) + } else { + Err(AuthError::DomainNotAllowed { domain: h }) + } + } + } + } + +### D5. Layer ordering + +Router assembly in `http/mod.rs::build_router`: + + let trace = tower_http::trace::TraceLayer::new_for_http(); + let request_id = tower_http::request_id::SetRequestIdLayer::x_request_id( + tower_http::request_id::MakeRequestUuid); + let propagate_id = tower_http::request_id::PropagateRequestIdLayer::x_request_id(); + + let cors = CorsLayer::new() + .allow_origin(cfg.server.allowed_origins()) + .allow_methods([Method::GET, Method::POST, Method::PUT, Method::DELETE, Method::OPTIONS]) + .allow_headers([header::CONTENT_TYPE, header::AUTHORIZATION, + HeaderName::from_static("x-api-key"), + HeaderName::from_static("x-vestige-domain"), + HeaderName::from_static("mcp-session-id")]) + .allow_credentials(true); + + let app = Router::new() + // Unauth routes first (not subjected to auth_layer by path allowlist) + .route("/api/health", get(health)) + .route("/dashboard/login", post(login)) + .route("/dashboard/logout", post(logout)) + // MCP + REST + dashboard + .route("/mcp", post(http::mcp::post_mcp).get(http::mcp_sse::get_mcp_sse) + .delete(http::mcp::delete_mcp)) + .nest("/api/v1", http::rest::router()) + .merge(dashboard::router()) + // Auth middleware applied via from_fn_with_state (allowlist inside) + .layer(axum::middleware::from_fn_with_state(ctx.clone(), auth_layer)) + // Outermost: tracing, request-id, cors, body limit, concurrency + .layer( + ServiceBuilder::new() + .layer(trace) + .layer(request_id) + .layer(propagate_id) + .layer(cors) + .layer(DefaultBodyLimit::max(MAX_BODY_SIZE)) + .layer(ConcurrencyLimitLayer::new(CONCURRENCY_LIMIT)) + ) + .with_state(ctx); + +Axum applies `layer()` calls outermost-first in the order they are declared. +The result here: request -> trace -> request-id -> CORS -> body-limit -> +concurrency -> auth -> handler. Auth must wrap the handlers but be inside +tracing so its spans can log auth outcomes. + +### D6. MCP endpoints + +File: `crates/vestige-mcp/src/http/mcp.rs` + +`POST /mcp` -- keep the session-based structure already in `protocol/http.rs` +but use the `Identity` injected by the auth layer instead of a shared +`auth_token`: + + pub async fn post_mcp( + State(ctx): State>, + Extension(id): Extension, + headers: HeaderMap, + Json(request): Json, + ) -> Response { ... } + +Auth happens in the layer, so this handler cannot be reached without a valid +`Identity`. Scope check: all MCP writes (tools that mutate) require +`RequireScope`. Use an enum of MCP methods or a method -> required-scope +map. `tools/list`, `resources/list`, `initialize`, `ping` are read-only. +`tools/call` is conservatively classified as write; the per-tool dispatch +inside `McpServer::handle_tools_call` may further reject writes when the tool +name is read-only and the key lacks write. + +`DELETE /mcp` -- unchanged semantics, drops the session. + +`GET /mcp` -- SSE. Implementation in `http/mcp_sse.rs`: + + use axum::response::sse::{Event, KeepAlive, Sse}; + use axum::extract::Query; + use futures_util::stream::Stream; + use async_stream::stream; + use std::time::Duration; + + #[derive(serde::Deserialize)] + pub struct SseParams { + pub op: String, // "dream" | "consolidate" | "discover" | "reassign" + pub session: Option, // optional operation correlation id + } + + pub async fn get_mcp_sse( + State(ctx): State>, + Extension(_id): Extension, + Query(params): Query, + ) -> Result>>, AuthError> { + let op = params.op.clone(); + let ctx2 = ctx.clone(); + let s = stream! { + yield Ok(Event::default().event("start").data(format!("{{\"op\":\"{}\"}}", op))); + match op.as_str() { + "dream" => { + let mut rx = ctx2.cognitive.lock().await.begin_dream_stream().await; + while let Some(ev) = rx.recv().await { + yield Ok(Event::default().event("progress").json_data(ev)?); + } + yield Ok(Event::default().event("done").data("{}")); + } + "consolidate" => { /* same pattern over Storage::run_consolidation_stream */ } + "discover" => { /* Phase 4 */ } + "reassign" => { /* Phase 4 */ } + other => { + yield Ok(Event::default().event("error") + .data(format!("{{\"message\":\"unknown op {}\"}}", other))); + } + } + }; + Ok(Sse::new(s).keep_alive(KeepAlive::new().interval(Duration::from_secs(15)))) + } + +SSE event shape (stable contract, document in `docs/http-api.md`): + + event: start + data: {"op":"dream"} + + event: progress + data: {"stage":"replay","processed":12,"total":50} + + event: progress + data: {"stage":"cross_reference","processed":25,"total":50} + + event: done + data: {"nodes_processed":50,"duration_ms":14320} + +The `keep-alive` hint is 15s to survive most proxy timeouts. + +### D7. REST API + +File: `crates/vestige-mcp/src/http/rest.rs` + +Routes: + + pub fn router() -> Router> { + Router::new() + .route("/health", get(health)) + .route("/memories", post(create_memory).get(list_memories)) + .route("/memories/{id}", get(get_memory).put(update_memory).delete(delete_memory)) + .route("/memories/{id}/promote", post(promote_memory)) + .route("/memories/{id}/demote", post(demote_memory)) + .route("/search", post(search_memories)) + .route("/consolidate", post(trigger_consolidation)) + .route("/stats", get(get_stats)) + .route("/domains", get(list_domains)) + .route("/domains/discover", post(trigger_discovery)) + .route("/domains/{id}", put(rename_domain).delete(delete_domain)) + .route("/domains/{id}/merge", post(merge_domain)) + .route("/keys", post(create_key).get(list_keys)) + .route("/keys/{id}", delete(revoke_key)) + } + +Representative signatures: + + #[derive(serde::Deserialize)] + pub struct CreateMemoryReq { + pub content: String, + pub node_type: Option, + pub tags: Option>, + pub source: Option, + pub metadata: Option, + } + + #[derive(serde::Serialize)] + pub struct MemoryView { /* flat projection of MemoryRecord */ } + + pub async fn create_memory( + State(ctx): State>, + Extension(id): Extension, + _: RequireScope, + Json(req): Json, + ) -> Result<(StatusCode, Json), ApiError> { + let effective = effective_domain_filter(&id, None)?; + let rec = ctx.store.insert_from_rest(req, effective).await?; + Ok((StatusCode::CREATED, Json(MemoryView::from(rec)))) + } + + pub async fn search_memories( + State(ctx): State>, + Extension(id): Extension, + _: RequireScope, + headers: HeaderMap, + Json(req): Json, + ) -> Result, ApiError> { + let dom_header = headers.get("x-vestige-domain").and_then(|h| h.to_str().ok()); + let effective = effective_domain_filter(&id, dom_header)?; + let q = SearchQuery { domains: effective, ..req.into() }; + let res = ctx.store.search(&q).await?; + Ok(Json(SearchResp::from(res))) + } + +`trigger_consolidation` returns 202 Accepted + a JSON body with a `session_id` +the client may pass to `GET /mcp?op=consolidate&session=...` to stream +progress. + +### D8. Error mapping + +File: `crates/vestige-mcp/src/http/errors.rs` + + #[derive(Debug, thiserror::Error)] + pub enum ApiError { + #[error(transparent)] Auth(#[from] AuthError), + #[error("bad request: {0}")] BadRequest(String), + #[error("not found")] NotFound, + #[error("conflict: {0}")] Conflict(String), + #[error(transparent)] Store(#[from] anyhow::Error), + } + + impl IntoResponse for ApiError { + fn into_response(self) -> Response { + match self { + ApiError::Auth(a) => a.into_response(), + ApiError::BadRequest(m) => (StatusCode::BAD_REQUEST, problem(400, "bad_request", &m)).into_response(), + ApiError::NotFound => (StatusCode::NOT_FOUND, problem(404, "not_found", "")).into_response(), + ApiError::Conflict(m) => (StatusCode::CONFLICT, problem(409, "conflict", &m)).into_response(), + ApiError::Store(e) => { + tracing::error!(err = %e, "store error"); + (StatusCode::INTERNAL_SERVER_ERROR, problem(500, "internal", "internal error")).into_response() + } + } + } + } + +All MCP JSON-RPC error mapping is unchanged (done in `McpServer`); only +transport-level errors (401/403) leave that path. + +### D9. Config loader and bind-safety check + +File: `crates/vestige-mcp/src/config.rs` + + #[derive(Debug, Clone, serde::Deserialize)] + pub struct ServerConfig { + #[serde(default = "default_bind")] + pub bind: String, // "127.0.0.1:3928" + #[serde(default = "default_dashboard_port")] + pub dashboard_port: u16, + #[serde(default)] pub tls_cert: Option, + #[serde(default)] pub tls_key: Option, + #[serde(default)] pub allowed_origins: Vec, + } + + #[derive(Debug, Clone, serde::Deserialize)] + pub struct AuthConfig { + #[serde(default = "default_true")] + pub enabled: bool, + #[serde(default)] pub session_secret_file: Option, + } + + impl ServerConfig { + pub fn parsed_bind(&self) -> anyhow::Result { + self.bind.parse().map_err(|e: std::net::AddrParseError| + anyhow::anyhow!("invalid bind {}: {}", self.bind, e)) + } + } + +Bind-safety check (called during `start_server`): + + pub fn enforce_bind_safety(server: &ServerConfig, auth: &AuthConfig) -> anyhow::Result<()> { + let addr = server.parsed_bind()?; + let is_loopback = match addr.ip() { + std::net::IpAddr::V4(v) => v.is_loopback(), + std::net::IpAddr::V6(v) => v.is_loopback(), + }; + if !is_loopback && !auth.enabled { + anyhow::bail!( + "refusing to bind {} with auth disabled; \ + set [auth] enabled = true in vestige.toml or \ + change [server] bind to a loopback address", + addr + ); + } + Ok(()) + } + +`main.rs` and the `serve` CLI both call `enforce_bind_safety` before +`TcpListener::bind`. On failure: `eprintln!` the error, `std::process::exit(2)`. + +Env bridge: + +- `VESTIGE_HTTP_BIND` (existing) -> `server.bind` host part. +- `VESTIGE_HTTP_PORT` (existing) -> `server.bind` port part. +- `VESTIGE_DASHBOARD_PORT` (existing) -> `server.dashboard_port`. +- `VESTIGE_AUTH_TOKEN` (deprecated) -- when set, synthesize a virtual + `ApiKeyRecord` with `id = all-zero UUID`, `scopes = [read, write]`, + `domain_filter = []`, `active = true`, hash stored in memory only. Log a + warning on every startup: `VESTIGE_AUTH_TOKEN is deprecated; use 'vestige + keys create' and set auth.enabled=true instead. Will be removed in v2.2.0.` +- `VESTIGE_SESSION_SECRET` -- see D3. + +### D10. Dashboard login + logout + +File: `crates/vestige-mcp/src/dashboard/handlers.rs` (additions). + + #[derive(serde::Deserialize)] + pub struct LoginBody { + pub api_key: String, + } + + pub async fn login( + State(state): State, + jar: SignedCookieJar, + headers: HeaderMap, + body: Option>, + ) -> Result<(SignedCookieJar, Json), AuthError> { + // Accept key in either JSON body or X-API-Key header + let plaintext = body.map(|b| b.0.api_key) + .or_else(|| headers.get("x-api-key").and_then(|h| h.to_str().ok()).map(String::from)) + .ok_or(AuthError::MissingCredentials)?; + + let hash = crate::auth::keys::hash_key(&plaintext); + let rec = state.store.find_api_key_by_hash(&hash).await + .map_err(|_| AuthError::Internal)? + .ok_or(AuthError::InvalidCredentials)?; + if !rec.active { return Err(AuthError::Revoked); } + + let secure = state.config.server.tls_cert.is_some(); + let jar = crate::auth::session::issue_session(jar, rec.id, secure); + + Ok((jar, Json(serde_json::json!({ + "ok": true, "key_id": rec.id, "label": rec.label, + "scopes": rec.scopes.iter().map(|s| s.as_str()).collect::>(), + "domains": rec.domain_filter, + })))) + } + + pub async fn logout(jar: SignedCookieJar) + -> (SignedCookieJar, Json) + { + (crate::auth::session::revoke_session(jar), + Json(serde_json::json!({"ok": true}))) + } + +Dashboard router integration: login/logout are appended before `auth_layer` +is applied, so they are reachable unauthenticated. The dashboard SPA asset +routes (`/dashboard`, `/dashboard/{*path}`) remain publicly readable so the +login page can load; the `/api/*` dashboard endpoints are gated by +`auth_layer`. (The existing health endpoint keeps its current behaviour.) + +### D11. `vestige keys` CLI + +File: `crates/vestige-mcp/src/bin/cli.rs` additions. + + #[derive(Subcommand)] + enum Commands { + // ... existing + /// Manage API keys + Keys { + #[command(subcommand)] + sub: KeyCmd, + }, + } + + #[derive(Subcommand)] + enum KeyCmd { + /// Create a new API key + Create { + #[arg(long)] label: String, + #[arg(long, value_delimiter = ',', default_values_t = ["read".to_string(), "write".to_string()])] + scopes: Vec, + /// Restrict the key to listed domains (comma-separated). Empty = all domains. + #[arg(long, value_delimiter = ',')] + domains: Vec, + }, + /// List existing keys (never shows plaintext) + List { + /// Include revoked keys in the output + #[arg(long)] all: bool, + }, + /// Revoke a key by id or by hash prefix + Revoke { + /// Id (UUID) or hash prefix (first 12 hex chars) + id_or_prefix: String, + }, + /// Revoke and re-create with the same scopes/label + Rotate { + id_or_prefix: String, + }, + } + +`Create` outputs the plaintext exactly once on stdout (for piping into env +files) and a confirmation on stderr. Use colored output only on stderr to keep +stdout machine-readable. + + fn run_keys_create(...) -> anyhow::Result<()> { + let store = open_store()?; // Arc + let plaintext = crate::auth::keys::generate_key(); + let hash = crate::auth::keys::hash_key(plaintext.as_str()); + let rec = ApiKeyRecord { + id: uuid::Uuid::new_v4(), + key_hash: hash, label, scopes, domain_filter: domains, + created_at: chrono::Utc::now(), + last_used: None, active: true, + }; + block_on(store.create_api_key(&rec))?; + + // stderr: human-readable + eprintln!("{} {}", "Created key:".green().bold(), rec.label); + eprintln!(" id: {}", rec.id); + eprintln!(" scopes: {}", rec.scopes.iter().map(|s| s.as_str()).collect::>().join(",")); + eprintln!(" domains: {}", if rec.domain_filter.is_empty() { "all".to_string() } else { rec.domain_filter.join(",") }); + eprintln!(); + eprintln!("{}", "Store the plaintext key now. It will not be shown again.".yellow()); + // stdout: ONLY the plaintext, for scripting + println!("{}", plaintext.as_str()); + Ok(()) + } + +`List`: + + kid label scopes domains last_used hash + d3a8... macbook read,write all 2026-04-20 11:02 a1b2c3d4e5f6 + ... + +Never print the plaintext. Show only `hash[..12]`. + +### D12. Migrations + +Postgres `0300_api_keys.sql` (idempotent; Phase 2 may have already created the +table, in which case this migration is a no-op `CREATE TABLE IF NOT EXISTS`): + + CREATE TABLE IF NOT EXISTS api_keys ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + key_hash TEXT NOT NULL UNIQUE, + label TEXT NOT NULL, + scopes TEXT[] NOT NULL DEFAULT ARRAY['read','write'], + domain_filter TEXT[] NOT NULL DEFAULT ARRAY[]::TEXT[], + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + last_used TIMESTAMPTZ, + active BOOLEAN NOT NULL DEFAULT true + ); + + CREATE INDEX IF NOT EXISTS idx_api_keys_active + ON api_keys (active) WHERE active; + +SQLite `0300_api_keys.sql`: + + CREATE TABLE IF NOT EXISTS api_keys ( + id TEXT PRIMARY KEY, + key_hash TEXT NOT NULL UNIQUE, + label TEXT NOT NULL, + scopes TEXT NOT NULL DEFAULT 'read,write', -- comma-joined + domain_filter TEXT NOT NULL DEFAULT '', -- comma-joined, '' = all + created_at TEXT NOT NULL DEFAULT (datetime('now')), + last_used TEXT, + active INTEGER NOT NULL DEFAULT 1 + ); + + CREATE INDEX IF NOT EXISTS idx_api_keys_active + ON api_keys (active) WHERE active = 1; + +Both backends' trait impls convert to/from `ApiKeyRecord`. + +### D13. Wiring main.rs and the `serve` CLI path + +`main.rs` refactor: + +1. `Config::load()` reads `vestige.toml` (if present) and overlays env vars. +2. Run `enforce_bind_safety(&cfg.server, &cfg.auth)` before spawning any + listener. On failure, print to stderr and exit 2. +3. Build `AppCtx` with `Arc`, `CognitiveEngine`, + event bus, `session_key`, `config`. +4. `build_router(ctx)` returns a single Axum `Router` that covers MCP, REST, + and dashboard. +5. `axum::serve(listener, app).await`. +6. The stdio MCP transport continues to run in parallel (unchanged) for + desktop / Claude Code single-user scenarios. + +`serve` CLI subcommand: identical flow minus stdio. + +### D14. Docs + +- `docs/env-vars.md` new: table of every supported env var, default, purpose, + deprecation status. +- Section in `README.md`: "Running Vestige as a network server". +- Cheat-sheet section in `CLAUDE.md` for: create a key, start the server, + curl smoke test. + +## Test Plan + +### Unit tests (colocated under `#[cfg(test)]`) + +- `auth/keys.rs`: + - `generate_key_has_prefix_and_length()` -- asserts `vst_` prefix and 34-ish + char total, regex `^vst_[A-Za-z0-9_-]{29}$`. + - `hash_key_blake3_is_stable_and_hex()` -- fixed vector test. + - `verify_key_accepts_same_input()` / `verify_key_rejects_tampered()` / + `verify_key_rejects_length_mismatch()`. + - `keys_are_unique_in_a_loop()` -- 10_000 iterations, no collisions. + - `plaintext_zeroed_on_drop()` -- unsafe peek into the backing buffer + through a wrapper that exposes bytes for the test only. + +- `auth/session.rs`: + - `round_trip_claims_through_signed_jar()`. + - `expired_cookie_is_rejected()` -- mint a cookie with `exp = iat - 60` and + confirm `claims_from` returns `None`. + - `tampered_cookie_is_rejected()` -- flip one byte in the signed segment, + confirm the jar drops it. + - `session_key_env_overrides_file()`. + - `session_key_generated_file_has_mode_0600_on_unix()`. + +- `auth/middleware.rs`: + - `extract_credentials_prefers_bearer_over_api_key_header()`. + - `extract_credentials_falls_back_to_cookie()`. + - `effective_domain_filter_empty_means_all()`. + - `effective_domain_filter_header_narrows_within_key_filter()`. + - `effective_domain_filter_rejects_header_outside_key_filter()`. + - `missing_credentials_returns_401()`. + - `revoked_key_returns_401()`. + - `insufficient_scope_returns_403()`. + +- `config.rs`: + - `parse_vestige_toml_with_server_and_auth_sections()`. + - `env_vars_override_toml_bind()`. + - `enforce_bind_safety_rejects_0_0_0_0_with_auth_disabled()`. + - `enforce_bind_safety_allows_0_0_0_0_with_auth_enabled()`. + - `enforce_bind_safety_allows_loopback_with_auth_disabled()`. + +- `http/errors.rs`: + - `not_found_emits_problem_json_with_correct_content_type()`. + - `bad_request_includes_detail_field()`. + +- `http/mcp.rs`: + - `post_mcp_unauth_returns_401()` (this would normally be caught by the + middleware; kept as a unit test by constructing the Router minus the + middleware to exercise the handler's own error paths). + +### Integration tests (`tests/phase_3/`) + +All tests spin up the full Axum stack in-process on a random port via +`tokio::net::TcpListener::bind("127.0.0.1:0")`, wire a `SqliteMemoryStore` in +a `TempDir`, and issue HTTP calls with `reqwest`. + +Files (each one a standalone binary test file): + +- `phase_3/common/mod.rs` -- shared harness (`spawn_server()`, + `create_test_key()`, `client()`). + +- `phase_3/http_mcp_round_trip.rs` -- boot server, mint a key, send + `initialize` over `POST /mcp` with `Authorization: Bearer vst_...`, follow + with `tools/list`, assert we see the expected tool count (greater than 20). + +- `phase_3/http_sse_stream.rs` -- `POST /api/v1/consolidate` returns 202 + + `session_id`. `GET /mcp?op=consolidate&session=...` streams at least one + `progress` and one `done` event. Use `eventsource-client` dev dep, or parse + the stream manually. + +- `phase_3/rest_api_crud.rs` -- exercises each REST endpoint in turn: + - `POST /api/v1/memories` -> 201 + body. + - `GET /api/v1/memories/{id}` -> 200. + - `PUT /api/v1/memories/{id}` -> 200. + - `POST /api/v1/search` -> 200 with the new memory in results. + - `POST /api/v1/memories/{id}/promote` -> 200. + - `GET /api/v1/stats` -> 200. + - `GET /api/v1/domains` -> 200 (likely empty). + - `DELETE /api/v1/memories/{id}` -> 204. + +- `phase_3/auth_bearer_token.rs`: + - unauth: `GET /api/v1/stats` returns 401 and `Content-Type: + application/problem+json`. + - valid Bearer: same call returns 200. + - revoked key: `POST /api/v1/keys/{id}` DELETE then reuse -> 401. + - tampered Bearer (last char flipped) -> 401. + +- `phase_3/auth_api_key_header.rs`: + - `X-API-Key: vst_...` alone -> 200. + - Both Bearer and X-API-Key with different values -> Bearer wins (asserted + via a key that is read-only in Bearer + full-scope X-API-Key, then + confirming a write 403s). + +- `phase_3/auth_session_cookie.rs`: + - `POST /dashboard/login` with valid key -> 200 + `Set-Cookie: + vestige_session=...; HttpOnly; SameSite=Strict; Path=/`. + - reuse cookie: `GET /api/v1/stats` returns 200. + - tampered cookie (change one char): -> 401. + - `POST /dashboard/logout` -> `Set-Cookie: vestige_session=; Max-Age=0`. + +- `phase_3/auth_domain_filter.rs`: + - Key with `domain_filter = ["dev"]`: + - `POST /api/v1/search` without header -> search is scoped to `["dev"]` + (insert fixtures with two domains, assert only `dev` rows returned). + - `X-Vestige-Domain: dev` -> same. + - `X-Vestige-Domain: home` -> 403 with detail `domain not permitted`. + - Key with empty filter + `X-Vestige-Domain: dev` -> scoped to `["dev"]`. + - Key with empty filter + no header -> no scoping. + +- `phase_3/auth_scope_enforcement.rs`: + - read-only key cannot call `POST /api/v1/memories` -> 403. + - read-only key CAN call `POST /api/v1/search` -> 200. + +- `phase_3/bind_safety_nonlocalhost_without_auth.rs`: + - Spawn `vestige serve --bind 0.0.0.0:0` as a subprocess with `auth.enabled + = false` via a temp `vestige.toml`. + - Assert: non-zero exit, stderr contains `refusing to bind`, no listener + ever opens (confirm by trying to connect to the configured port and + expecting connection refused after a short timeout). + +- `phase_3/cli_keys_create_list_revoke.rs`: + - Spawn the `vestige` CLI binary with `--data-dir `. + - Run `vestige keys create --label test --scopes read,write`; capture + stdout (the plaintext) and stderr (the human summary). Assert `vst_` + prefix in stdout. + - Run `vestige keys list`; assert no plaintext, label `test` present. + - Run `vestige keys revoke `; confirm exit 0. + - Run `vestige keys list`; assert label no longer visible without `--all`. + +- `phase_3/dashboard_login_flow.rs`: + - Full loop: login -> fetch `/dashboard` (gets SPA index, unauthed ok) -> + fetch `/api/memories` (authed via cookie) -> logout -> fetch `/api/memories` + (401). + +- `phase_3/deprecation_auth_token.rs`: + - Start the server with `VESTIGE_AUTH_TOKEN=test12345...` and no created + keys. Send a Bearer request with that token -> 200. Assert stderr log + contains `deprecated`. + +### Smoke test (`tests/phase_3/smoke/`) + +- `remote_mcp_client.sh`: + + #!/usr/bin/env bash + set -euo pipefail + KEY="${VESTIGE_TEST_KEY:?set me}" + HOST="${VESTIGE_HOST:-http://127.0.0.1:3928}" + # Initialize a session + RESP=$(curl -sS -D /tmp/h -H "Authorization: Bearer $KEY" \ + -H "Content-Type: application/json" \ + -d '{"jsonrpc":"2.0","id":1,"method":"initialize", + "params":{"protocolVersion":"2025-11-25", + "clientInfo":{"name":"smoke","version":"0"}, + "capabilities":{}}}' \ + "$HOST/mcp") + SID=$(grep -i 'mcp-session-id:' /tmp/h | awk '{print $2}' | tr -d '\r') + # tools/list + curl -sS -H "Authorization: Bearer $KEY" \ + -H "Mcp-Session-Id: $SID" \ + -H "Content-Type: application/json" \ + -d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}' \ + "$HOST/mcp" | jq '.result.tools | length' + echo "smoke ok" + +## Acceptance Criteria + +- [ ] `cargo build -p vestige-mcp` -- zero warnings, all feature combinations + (`--no-default-features`, default, `--features ort-dynamic`). +- [ ] `cargo clippy --workspace --all-targets --all-features -- -D warnings`. +- [ ] `cargo fmt --all --check`. +- [ ] All `tests/phase_3/*.rs` pass, plus phase_1 and phase_2 remain green. +- [ ] Unauth request to `POST /mcp` returns 401 with + `Content-Type: application/problem+json` and a body containing `status`, + `title`, `detail`. +- [ ] Binding `0.0.0.0:` with `[auth].enabled = false` makes the + process exit with code 2 and print `refusing to bind` to stderr. +- [ ] `vestige keys create --label X` prints exactly one line on stdout + matching `^vst_[A-Za-z0-9_-]+$`; `vestige keys list` never prints that + line back. +- [ ] Dashboard login from a browser-like client (tested via the reqwest + `Client::cookie_store(true)` harness) yields a `Set-Cookie` with + `HttpOnly`, `SameSite=Strict`, `Path=/`, and Max-Age present. +- [ ] A second machine can run a curl-based MCP client against the server + (smoke test) and receive successful `tools/list` responses. +- [ ] `VESTIGE_AUTH_TOKEN` still works and emits the deprecation warning. +- [ ] `tests/phase_3/auth_domain_filter.rs` demonstrates that a key scoped to + `dev` cannot read `home`-domain memories via any of the three auth modes + and cannot escape with `X-Vestige-Domain`. + +## Rollback Notes + +- Ship behind an on-by-default Cargo feature `http-server` on + `vestige-mcp`. Disabling it reverts to stdio + existing localhost HTTP + (`protocol/http.rs` in its current form) with zero behaviour change. +- SQL: migration `0300_api_keys.sql` is additive only; rollback is a single + `DROP TABLE api_keys;` in `0300_api_keys.down.sql` for both backends. Keep a + row count safety check in the down migration and log the deletion. +- Session secret file: deleting `/session_secret` invalidates every + outstanding cookie; users simply log in again. Safe to rotate. +- Env var sunset schedule: + - v2.1.x: `VESTIGE_AUTH_TOKEN` emits a warning, still works. + - v2.2.0: `VESTIGE_AUTH_TOKEN` refused with an error pointing at + `vestige keys create`. +- Downgrade procedure: `git revert` the Phase 3 merge, then run the down + migration. No data loss; plaintext keys were only ever in user-side + secret managers. + +## Open Implementation Questions + +1. JSON-RPC library: hand-rolled vs jsonrpsee? + + - Candidate A: keep the hand-rolled types in `protocol/types.rs` plus the + session-aware `post_mcp` handler already in `protocol/http.rs`. + - Candidate B: switch to `jsonrpsee = "0.24"` with the `server` feature + and adapt it to Axum via `jsonrpsee::server::Server`. + + RECOMMENDATION: A. Phase 3 is about auth and transport surfaces, not + library rewrites. The existing types are already correct, tested, and + compatible with Streamable HTTP; the 29 cognitive modules depend on + `McpServer::handle_request`, which does not map 1:1 to jsonrpsee's + `RpcModule` trait. Re-evaluate in a future phase only if we need subscription + notifications beyond SSE. + +2. Streamable HTTP vs plain POST-with-JSON? + + - The MCP spec titled "Streamable HTTP" defines: `POST /mcp` for + request/response, `GET /mcp` for SSE where the client subscribes to + server-initiated messages, and an `Mcp-Session-Id` header for session + correlation. The current implementation already covers POST + session + header + DELETE; Phase 3 adds the GET/SSE half. + + RECOMMENDATION: implement the full Streamable HTTP transport. Long-running + tools (dream, consolidate, discover) benefit from SSE progress events, and + Claude Desktop / Claude Code both speak Streamable HTTP natively. Keeping + POST-only would work for short calls but block the UX we want for + background jobs. + +3. Session cookie crate? + + - Candidate A: `axum-extra::extract::cookie::SignedCookieJar` with a 64-byte + `Key`. + - Candidate B: `tower-sessions = "0.13"` with the `MemoryStore` or + `PostgresStore` session backend. + - Candidate C: stateless JWT via `jsonwebtoken`. + + RECOMMENDATION: A. We do not need server-side session state (the `api_keys` + row is the state; the cookie is merely a signed pointer to it). B adds a + whole storage backend we do not need. C adds signing-algorithm surface area + and revocation becomes awkward ("revoked key" with a long-lived JWT). + `SignedCookieJar` gives us HMAC-signed cookies for free, integrates with + axum extractors, and the payload is tiny. + +4. Key format and length? + + - 22 random bytes base64url-no-pad = 176 bits entropy, encoded ~30 chars, + full key ~34 chars with the `vst_` prefix. Long enough to make + brute-force infeasible, short enough to paste into config files. + - Alternatives: 32 bytes (40 chars, overkill), 16 bytes (128 bits, marginal + for secret material shared over networks). + + RECOMMENDATION: 22 bytes. Prefix `vst_` is already documented in the PRD + and gives grep-ability. + +5. Rate limiting: in scope for Phase 3? + + - Useful: mitigates slow brute force, runaway agents. + - Expensive to design well (per-key, per-IP, per-endpoint). + + RECOMMENDATION: OUT of scope. Track as `docs/adr/0002-rate-limiting.md` + follow-up. Axum + `tower` has `ConcurrencyLimitLayer` (already used); a + follow-up can add `governor` or `tower_governor` behind the auth layer so + identity is available. + +6. CORS policy defaults for dashboard in server mode? + + - Candidate A: allow only origins derived from `server.bind` host + the + dashboard port. + - Candidate B: allow user-listed origins via `server.allowed_origins` + config, with A as fallback. + - Candidate C: open CORS to `*` when TLS is configured. + + RECOMMENDATION: B. Auto-populate `allowed_origins` from the bind address + and dashboard port at start time; if the operator sets the config list, + use that list verbatim. Never `*` (`allow_credentials = true` is + incompatible with `*` anyway). + +7. Dashboard session lifetime? + + - 8 hours for default; configurable via `auth.session_ttl_hours`. + - Rotate on each write? (Rolling sessions.) + + RECOMMENDATION: 8 hours fixed, non-rolling. Revisit if users complain. + +8. Handling `tools/call` scope granularity? + + - Today, `tools/call` is a single MCP method. Read-only tools like + `search`, `deep_reference`, `predict` should be callable with a + read-only key. + + RECOMMENDATION: map tool names to scopes in `McpServer::handle_tools_call`. + Read-only names: `search`, `session_context`, `memory` with action in + `{get, state, get_batch}`, `deep_reference`, `cross_reference`, `predict`, + `explore_connections`, `find_duplicates`, `memory_timeline`, + `memory_changelog`, `memory_health`, `memory_graph`, `importance_score`, + `system_status`. Everything else requires `write`. If a read-only key + calls a write tool, return a JSON-RPC error with code `-32003` + ("server not initialized" is close but wrong; reuse `-32603 internal` with + a descriptive message or add a new `-32004 UnauthorizedTool`). RECOMMEND + adding `-32004`. + +9. How to bridge `MemoryStore` trait with dashboard state (`AppState`)? + + - Today `AppState.storage: Arc` is a concrete type. + - Phase 2 introduces `Arc`. + + RECOMMENDATION: in Phase 3, introduce `AppCtx { store: Arc, + cognitive, config, event_tx }` as the single state type for the unified + router. Keep `AppState` as a thin wrapper (or alias) if the dashboard + handlers need to stay untouched in this phase. Migrate the dashboard + handlers to the trait in a follow-up refactor to contain the blast radius. + +10. Windows support for `session_secret` and `auth_token` file modes? + + - Unix gets `0600` via `OpenOptionsExt`. + - Windows has no direct equivalent; ACLs differ. + + RECOMMENDATION: document the limitation; use default permissions on + Windows. Add a `#[cfg(windows)]` placeholder to set owner-only ACLs via + `windows-acl` in a follow-up, not Phase 3. + +### Critical Files for Implementation + +- /home/delandtj/prppl/vestige/crates/vestige-mcp/src/protocol/http.rs +- /home/delandtj/prppl/vestige/crates/vestige-mcp/src/dashboard/mod.rs +- /home/delandtj/prppl/vestige/crates/vestige-mcp/src/main.rs +- /home/delandtj/prppl/vestige/crates/vestige-mcp/src/bin/cli.rs +- /home/delandtj/prppl/vestige/crates/vestige-mcp/Cargo.toml diff --git a/docs/plans/0004-phase-4-emergent-domain-classification.md b/docs/plans/0004-phase-4-emergent-domain-classification.md new file mode 100644 index 0000000..d9f2355 --- /dev/null +++ b/docs/plans/0004-phase-4-emergent-domain-classification.md @@ -0,0 +1,883 @@ +# Phase 4 Plan: Emergent Domain Classification + +**Status**: Draft +**Depends on**: Phase 1 (domain columns on memories, `Domain` struct + `DomainStore` methods on `MemoryStore`, `Embedder` trait), Phase 2 (Postgres JSONB + TEXT[] support for domain fields, `embedding_model` registry parity), Phase 3 (Axum HTTP server, REST `/api/v1/` scaffolding, API key auth middleware, signed dashboard session cookies) +**Related**: docs/adr/0001-pluggable-storage-and-network-access.md (Phase 4), docs/prd/001-getting-centralized-vestige.md (Emergent Domain Model) + +--- + +## Scope + +### In scope + +- `DomainClassifier` cognitive module under `crates/vestige-core/src/neuroscience/domain_classifier.rs`, alongside existing neuroscience modules (spreading_activation, synaptic_tagging, ...). +- HDBSCAN discovery pipeline using the `hdbscan` crate (v0.10): load all embeddings, cluster, extract centroids, extract top-terms via TF-IDF over cluster members, persist via the trait's `DomainStore` methods. +- Soft-assignment pipeline: for each memory, compute `cosine_similarity(memory.embedding, domain.centroid)` for every domain, store raw scores in `domain_scores` JSONB, threshold into `domains[]` using `assign_threshold` (default 0.65). +- Automatic classification on ingest: run through `CognitiveEngine` / `smart_ingest` so new memories get classified against existing centroids immediately; skip when `domain_count == 0` (Phase 0 accumulation). +- Re-cluster hook in dream consolidation: every Nth four-phase dream cycle (N=5 default) triggers a discovery pass and generates proposals (split / merge / none). Proposals land in a new `domain_proposals` table, surface in the dashboard, and are never auto-applied (conservative drift, ADR Q7). +- Context signals: `SignalSource` trait with `GitRepoSignal` (detects `.git` in CWD or `metadata.cwd`) and `IdeHintSignal` (reads `metadata.editor` / `metadata.ide`). Each returns a `boost_map` of `domain_id -> additive delta` (typical +0.05). Injected as a `signal_boost: Option>` parameter into `DomainClassifier::classify`. +- Cross-domain spreading activation decay: `ActivationNetwork` traversal multiplies the edge's effective weight by `cross_domain_decay` (default 0.5) when `target.domains` and `source.domains` are disjoint. Strict "no overlap" policy, not graded. +- CLI subcommands (in `crates/vestige-mcp/src/bin/cli.rs`, under a new `Domains` command group): `list`, `discover [--min-cluster-size N] [--force]`, `rename `, `merge [--into ]`. Human-readable tables on stdout; JSON via `--json`. +- Dashboard UI additions (`apps/dashboard/src/routes/(app)/domains/`): list page, per-domain detail (memories, centroid top_terms, score histogram, proposal review controls). +- REST endpoints under `/api/v1/domains` (introduced by Phase 3 skeleton, implemented in Phase 4): list, discover, rename, merge, proposal list / accept / reject. +- Config additions: `[domains]` section in `vestige.toml` covering `assign_threshold`, `recluster_interval`, `min_cluster_size`, `cross_domain_decay`, `discovery_threshold`, `merge_threshold`, `signal_boost` (per-signal toggle). + +### Out of scope + +- Phase 5 federation (explicit separate ADR). Domain centroids are installation-local; no sync. +- Learned re-weighting of domain scores (future, only if retrieval-quality metrics show a need). +- Interactive cluster-membership editing in the UI (drag-and-drop reassign) -- future enhancement. +- Multi-user domain namespaces. One domain set per installation; API keys that carry `domain_filter` just restrict access, they do not create namespaces. +- Auto-sweep of `min_cluster_size` / auto-tuned `assign_threshold` (ADR resolution Q6 + Q9: static defaults, user tunes). +- Graded cross-domain decay (`|A intersect B| / max(|A|,|B|)`) -- strict "no overlap" is the Phase 4 rule. + +--- + +## Prerequisites + +Artifacts that Phases 1-3 are expected to have landed: + +- In `vestige-core`: + - `Embedder` trait (`crates/vestige-core/src/embedder/`). + - `MemoryStore` trait (`crates/vestige-core/src/storage/trait.rs` or similar) including `DomainStore` methods: `list_domains`, `get_domain`, `upsert_domain`, `delete_domain`, `classify(&[f32]) -> Vec<(String, f64)>`, plus a bulk accessor such as `all_embeddings()` (already present in sqlite.rs as `get_all_embeddings`) and a `get_all_memories_with_embeddings()` iterator for discovery. The trait must expose a method to batch-update `(domains, domain_scores)` for a memory id. + - `Domain` struct: `{ id: String, label: String, centroid: Vec, top_terms: Vec, memory_count: usize, created_at: DateTime }`. + - Columns on memories in both SQLite and Postgres: `domains TEXT[]` (or JSON array on SQLite) and `domain_scores JSONB` (or TEXT JSON on SQLite). + - The `domains` table in both backends (see PRD schema sketch). +- In `vestige-mcp`: + - Axum `/api/v1/` router prefix with auth middleware. + - CLI skeleton (`bin/cli.rs`) using `clap`; Phase 4 adds a `Domains` subcommand tree. + - REST handlers file structure ready under `crates/vestige-mcp/src/dashboard/handlers.rs` (legacy) and a dedicated REST handler under `/api/v1/`; Phase 4 adds `domains.rs` handler module. + - SvelteKit dashboard (`apps/dashboard/`) with existing `(app)/memories`, `(app)/timeline`, `(app)/stats`, etc. Phase 4 adds `(app)/domains/`. + +New workspace crate additions required (added manually to `Cargo.toml`, since `cargo add` is not run from the plan): + +- `hdbscan = "0.10"` in `crates/vestige-core/Cargo.toml` (feature-gated behind `domain-classification`). +- Optional: a lightweight stop-word constant inline; no external stop-word crate -- the neuroscience modules already do tokenization on whitespace + length>3 (see `dreams.rs::content_similarity`). Reuse that style; no `ndarray` needed because `hdbscan` v0.10 accepts `&[Vec]` directly (verified from PRD snippet). +- No new deps in `vestige-mcp` for Phase 4 -- CLI reuses `clap` / `colored` / `comfy-table` if already present, otherwise a hand-rolled padded print. We pick hand-rolled to avoid adding a table crate; this matches the existing style of `run_stats` in `cli.rs`. + +Test fixtures: + +- A JSON seed corpus checked into `tests/phase_4/fixtures/seed_500.json` containing >= 500 memories drawn from three plausible clusters. A builder function `tests/phase_4/support/fixtures.rs::build_seed_corpus()` deterministically generates or loads this corpus. Each record has `content`, `tags`, `embedding` (768D bge-base-en-v1.5; use a committed vector or a deterministic mock embedder in tests). For deterministic tests we fake embeddings by hashing content -- acceptable as long as the fake preserves cluster separability (prefix-based: "DEV-...", "INFRA-...", "HOME-..." seeds three Gaussian blobs). +- Reuse `Embedder` mock from Phase 1 tests (`MockEmbedder`) for discovery tests that need real cosine similarity. +- A minimal git-repo fixture created in a tempdir (`tempfile::tempdir` + `std::process::Command::new("git").arg("init")`) for context-signal tests. + +--- + +## Deliverables + +1. `DomainClassifier` cognitive module: struct, defaults, `classify`, `classify_with_boost`, `reassign_all`, `discover`. +2. `domain_terms` helper (TF-IDF over cluster members, returning `top_k` terms). +3. `cli domains discover` subcommand. +4. `cli domains list` / `rename` / `merge` subcommands. +5. Auto-classify hook on ingest (wired into the cognitive engine's ingest pipeline before persistence). +6. Re-cluster hook in dream consolidation (`DreamEngine::run` orchestrator gets an optional `DomainReClusterHook`; triggers every Nth dream). +7. Context signal extractor module (`crates/vestige-core/src/neuroscience/context_signals.rs`) with `SignalSource` trait + `GitRepoSignal` + `IdeHintSignal`. +8. Cross-domain spreading activation decay in `ActivationNetwork::activate` (config-driven). +9. `vestige.toml` `[domains]` section + defaults loader. +10. Dashboard UI: SvelteKit routes `(app)/domains/+page.svelte` (list), `(app)/domains/[id]/+page.svelte` (detail), `(app)/domains/proposals/+page.svelte` (review). +11. REST endpoints under `/api/v1/domains` + `/api/v1/domains/proposals`. +12. `domain_proposals` table + migration + `DomainProposal` trait methods on `MemoryStore`. +13. WebSocket event `VestigeEvent::DomainProposalCreated` so the dashboard gets a live notification after a re-cluster fires. + +--- + +## Detailed Task Breakdown + +### 1. `DomainClassifier` cognitive module + +**File**: `crates/vestige-core/src/neuroscience/domain_classifier.rs` +**Export**: in `crates/vestige-core/src/neuroscience/mod.rs`, add `pub mod domain_classifier;` and re-export `pub use domain_classifier::{DomainClassifier, ClassificationResult, DomainProposal, ProposalKind};` +**Deps**: `hdbscan = "0.10"`, `serde`, `serde_json`, `chrono`, `tracing`, existing `crate::storage::Domain`, `crate::storage::MemoryStore` trait. + +Struct and defaults (match PRD exactly): + +```rust +pub struct DomainClassifier { + pub assign_threshold: f64, // default 0.65 + pub discovery_threshold: usize, // default 150 + pub recluster_interval: usize, // default 5 (every 5th dream) + pub min_cluster_size: usize, // default 10 + pub min_samples: usize, // default 5 (HDBSCAN) + pub cross_domain_decay: f64, // default 0.5 + pub merge_threshold: f64, // default 0.90 (centroid cosine) + pub top_terms_k: usize, // default 10 +} + +impl Default for DomainClassifier { ... } +``` + +Result types: + +```rust +#[derive(Debug, Clone)] +pub struct ClassificationResult { + pub scores: HashMap, // raw per-domain similarities + pub domains: Vec, // above assign_threshold +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum ProposalKind { + Split { parent: String, children: Vec }, + Merge { targets: Vec, suggested_label: String }, + NewCluster { top_terms: Vec }, +} + +#[derive(Debug, Clone)] +pub struct DomainProposal { + pub id: String, // uuid v4 + pub kind: ProposalKind, + pub rationale: String, + pub confidence: f64, + pub created_at: DateTime, + pub status: ProposalStatus, // Pending | Accepted | Rejected +} +``` + +Key methods (all pure where possible; all pub): + +```rust +impl DomainClassifier { + pub fn classify(&self, embedding: &[f32], domains: &[Domain]) -> ClassificationResult; + + pub fn classify_with_boost( + &self, + embedding: &[f32], + domains: &[Domain], + boost: Option<&HashMap>, + ) -> ClassificationResult; + + pub async fn reassign_all( + &self, + store: &dyn MemoryStore, + domains: &[Domain], + ) -> Result; + + pub async fn discover( + &self, + store: &dyn MemoryStore, + ) -> Result, StorageError>; + + pub async fn propose_changes( + &self, + store: &dyn MemoryStore, + existing: &[Domain], + newly_discovered: &[Domain], + ) -> Result, StorageError>; + + pub async fn apply_proposal( + &self, + store: &dyn MemoryStore, + proposal: &DomainProposal, + ) -> Result<(), StorageError>; +} +``` + +Behavior notes: + +- `classify` returns empty `{ scores: {}, domains: [] }` iff `domains.is_empty()` (accumulation phase). This matches the PRD snippet verbatim. +- `classify_with_boost` adds the boost delta to each score AFTER cosine, before thresholding. It clamps to `[0.0, 1.0]`. Boost keys not present in `domains` are ignored. +- `reassign_all` streams memories in batches of 500 (iterator on the store) to keep memory bounded; for each memory issues a single `UPDATE memories SET domains = ?, domain_scores = ? WHERE id = ?` call. Returns count of memories whose `domains` vector actually changed. +- `discover` loads all `(id, embedding)` pairs via an `all_embeddings()` method on the store (exists under `#[cfg(all(feature = "embeddings", feature = "vector-search"))]` in `sqlite.rs::get_all_embeddings`; Phase 1 should promote this onto the trait -- if not yet promoted, add the method). Then: + 1. Build `Vec>` and index -> id map. + 2. `Hdbscan::default_hyper_params(&embeddings).min_cluster_size(self.min_cluster_size).min_samples(self.min_samples).build()` (exact builder depends on hdbscan 0.10 surface; see Open Question). + 3. `let labels = clusterer.cluster()?;` + 4. `let centers = clusterer.calc_centers(Center::Centroid, &labels)?;` + 5. Group indices by label ignoring -1 (noise). For each cluster compute `top_terms` via `compute_top_terms`. + 6. Preserve stable IDs where possible: match each new cluster centroid to the closest existing domain by cosine; if similarity > 0.85, reuse the existing domain id + label. Otherwise generate a fresh id `cluster_{n}` with a label derived from the first 2 terms. + 7. Upsert all resulting `Domain`s via the store. +- `propose_changes` compares old vs new clusters: + - **Split**: an old domain that best-matches two or more new domains each with >= `min_cluster_size` members. Rationale: "domain `dev` is now 2 clusters of >=10 memories: `systems` and `networking`". + - **Merge**: two old domains whose centroids now satisfy `cosine > merge_threshold` get a merge proposal. + - **NewCluster**: a new cluster that doesn't match any old domain above 0.85 similarity. +- `apply_proposal` runs the split or merge against the store (reassign memberships via `reassign_all`), then marks the proposal `Accepted`. It never runs automatically -- only via the CLI or dashboard. + +Helper: + +```rust +fn compute_top_terms(documents: &[&str], k: usize) -> Vec; +``` + +Uses TF-IDF with IDF computed over the entire passed-in corpus (the `documents` slice), tokenization = whitespace split, lowercase, strip non-alphanumeric, drop tokens shorter than 4 chars and a small built-in stop-word list (`the`, `and`, `for`, `that`, `with`, ...). Matches the tokenizer used in `dreams.rs::content_similarity` and `dreams.rs::extract_patterns` so behavior is predictable. + +Cosine similarity helper: + +```rust +fn cosine_similarity(a: &[f32], b: &[f32]) -> f64; +``` + +Keep the existing crate-level `cosine_similarity` if already present (check `embeddings::` or `search::`); otherwise add a private one. Returns 0.0 on dimension mismatch, panics would be a bug. + +### 2. Top-terms computation helper + +**File**: same module, private section. + +- `fn tokenize(text: &str) -> Vec`: lowercase, split on non-alphanumeric, filter len >= 4, drop stop-words. +- `fn tfidf_top_k(docs: &[&str], k: usize) -> Vec`: + 1. `tf[doc_idx][term] = count / total_terms`. + 2. `df[term] = docs containing term`. + 3. `idf[term] = log((N + 1) / (df[term] + 1)) + 1` (smoothed). + 4. For each term, average `tf` across docs in the cluster; multiply by `idf`; sort desc; return top `k`. + +Cluster top-terms are computed over cluster members only, with IDF over the **whole corpus** (all memory contents), not the cluster, so common words get penalized globally. Recompute global IDF once per `discover` call. + +### 3. CLI subcommand: `vestige domains discover` + +**File**: `crates/vestige-mcp/src/bin/cli.rs` + +Add to `enum Commands`: + +```rust +/// Emergent domain management +Domains { + #[command(subcommand)] + action: DomainAction, +}, +``` + +```rust +#[derive(clap::Subcommand)] +enum DomainAction { + /// List all discovered domains + List { + #[arg(long)] json: bool, + }, + /// Run HDBSCAN discovery on all embeddings and propose domains + Discover { + #[arg(long, default_value_t = 10)] min_cluster_size: usize, + /// Skip the proposal flow and write new domains directly (first-time use) + #[arg(long)] force: bool, + #[arg(long)] json: bool, + }, + /// Rename a domain (by id) + Rename { + id: String, + new_label: String, + }, + /// Merge two domains + Merge { + a: String, + b: String, + #[arg(long)] into: Option, // default: `a` + }, +} +``` + +Handler plumbing lives in `run_domains(action)` dispatching to `run_domains_list`, `run_domains_discover`, `run_domains_rename`, `run_domains_merge`. Each opens the default `Storage`, constructs a `DomainClassifier::default()`, and invokes the appropriate method. + +Output format for `list`: + +``` +ID LABEL MEMORIES TOP TERMS +dev Development 87 rust, trait, async, tokio, zinit +infra Infrastructure 47 bgp, sonic, vlan, frr, peering +home Home 31 solar, kwh, battery, pool, esphome +(unclassified) 12 +``` + +Produced via plain `print!` with `%-15s %-18s %-10d %s` style padding. `--json` emits `serde_json::to_string_pretty(&domains)`. + +Output format for `discover` with `--force`: + +``` +HDBSCAN: 500 embeddings, min_cluster_size=10, min_samples=5 +Found 3 clusters (ignoring 14 noise points) + cluster_0 (N=47) top: bgp, sonic, vlan, frr, peering + cluster_1 (N=31) top: solar, kwh, battery, pool, esphome + cluster_2 (N=22) top: rust, trait, async, tokio, zinit + +Writing 3 domains to the store... +Soft-assigning 500 memories against centroids... + multi-domain: 43 + single-domain: 412 + unclassified (below threshold 0.65): 45 +Done in 7.4s. +``` + +Output format for `discover` without `--force` (post-Phase-0): + +``` +HDBSCAN: 623 embeddings, min_cluster_size=10 +Comparing to existing 3 domains... + +Proposals (pending, accept via dashboard or `vestige domains proposals`): + [split] dev -> (systems:34, networking:28) confidence 0.82 + [new] cluster_5 (books, novels, reading) confidence 0.71 + +Run `vestige domains proposals` to review, or open the dashboard. +``` + +### 4. CLI: `list`, `rename`, `merge` + +- `list`: calls `store.list_domains()`, fetches unclassified count via `store.count_memories_without_domains()` (Phase 1 should have provided this; if not, Phase 4 adds it to the trait and both backends). +- `rename`: `store.get_domain(id)` -> mutate `label` -> `store.upsert_domain`. No memory touch. +- `merge`: load both, compute blended centroid (weighted by `memory_count`), merge `top_terms` (union, recompute TF-IDF rank if both sides share the corpus), delete the non-`into` domain, call `reassign_all`. Wrapped in a transaction on Postgres; on SQLite rely on the existing writer-lock pattern. + +### 5. Auto-classify on ingest + +**File**: `crates/vestige-core/src/cognitive.rs` (or equivalent ingest entry in `vestige-mcp/src/tools/smart_ingest.rs`). + +Integration point: just before the record is persisted in the smart-ingest path, after the embedder has produced `embedding` and before `storage.insert(...)`. Trace the current call site -- today `Storage::ingest(IngestInput)` computes embedding inside storage; in Phase 1 the embedder becomes external (ADR decision Q2), so classification can hook right there in the cognitive engine. + +Pseudocode: + +```rust +let embedding = embedder.embed(&input.content).await?; +let domains = store.list_domains().await?; + +let (domains_assigned, domain_scores) = if domains.is_empty() { + (Vec::new(), HashMap::new()) +} else { + let boost = context_signals.gather_boost(&input.metadata, &domains); + let result = classifier.classify_with_boost(&embedding, &domains, boost.as_ref()); + (result.domains, result.scores) +}; + +record.embedding = Some(embedding); +record.domains = domains_assigned; +record.domain_scores = domain_scores; +store.insert(&record).await?; +``` + +Edge cases: + +- Accumulation phase (`domains.is_empty()`): skip classification entirely. Zero overhead. +- Embedding failed / skipped: leave `domains = []`, `domain_scores = {}`. Never fail ingest because of classification. +- Metric: emit `VestigeEvent::MemoryClassified { id, domains, top_score }` on the WebSocket bus so the dashboard sees it live. + +### 6. Re-cluster hook in dream consolidation + +**File**: `crates/vestige-core/src/advanced/dreams.rs` (long file, 1131-line `dream()` entry on the `MemoryDreamer` impl) plus `crates/vestige-core/src/consolidation/phases.rs` (the `DreamEngine::run` orchestrator). + +Design: the `DreamEngine::run(...)` returns `FourPhaseDreamResult`. It does not currently know how many times it has run. Phase 4 introduces a persistent counter on disk (column `dream_cycle_count` on a new singleton `system_state` table, or a simple row in the existing `metadata` / `embedding_model` registry). After the Integration phase finishes, the cognitive engine increments the counter and, if `counter % recluster_interval == 0`, launches discovery asynchronously: + +Extension struct in `phases.rs`: + +```rust +pub struct DreamReClusterHook<'a> { + pub classifier: &'a DomainClassifier, + pub store: &'a dyn MemoryStore, + pub event_tx: Option<&'a tokio::sync::mpsc::UnboundedSender>, +} + +impl<'a> DreamReClusterHook<'a> { + pub async fn tick(&self, cycle_count: usize) -> Result, StorageError> { + if cycle_count == 0 || cycle_count % self.classifier.recluster_interval != 0 { + return Ok(vec![]); + } + let existing = self.store.list_domains().await?; + let rediscovered = self.classifier.discover(self.store).await?; + let proposals = self + .classifier + .propose_changes(self.store, &existing, &rediscovered) + .await?; + for p in &proposals { + self.store.insert_domain_proposal(p).await?; + if let Some(tx) = self.event_tx { + let _ = tx.send(VestigeEvent::DomainProposalCreated { + id: p.id.clone(), + kind: format!("{:?}", p.kind), + confidence: p.confidence, + timestamp: Utc::now(), + }); + } + } + Ok(proposals) + } +} +``` + +Caller wires `tick()` after `DreamEngine::run()` returns, at the ingest/consolidation orchestrator level. The hook never mutates existing domains -- it only writes proposals. The acceptance path is manual (CLI or dashboard). + +Counter storage: add method `store.bump_dream_cycle_count() -> Result` returning the new count. Single-row table: + +```sql +CREATE TABLE IF NOT EXISTS system_state ( + key TEXT PRIMARY KEY, + value TEXT NOT NULL +); +-- seed: ('dream_cycle_count', '0') +``` + +### 7. Context signal extractor + +**File**: `crates/vestige-core/src/neuroscience/context_signals.rs` + +```rust +pub trait SignalSource: Send + Sync { + /// Returns domain_id -> additive boost (positive or negative, typically in [-0.1, +0.1]). + fn boost_map( + &self, + input_metadata: &serde_json::Value, + domains: &[Domain], + ) -> HashMap; + + fn name(&self) -> &'static str; +} + +pub struct GitRepoSignal { + pub boost: f64, // default +0.05 +} + +pub struct IdeHintSignal { + pub boost: f64, +} + +pub struct ContextSignals { + sources: Vec>, +} + +impl ContextSignals { + pub fn gather_boost( + &self, + input_metadata: &serde_json::Value, + domains: &[Domain], + ) -> Option>; +} +``` + +Signal encoding convention (document in the module header): + +- A signal is a **soft prior**. It nudges the post-cosine score by a small additive delta, clamped to `[-0.10, +0.10]` per signal. +- Multiple signals sum, then the final boost per domain is clamped to `[-0.15, +0.15]` so signals cannot by themselves push a memory into or out of a domain; the embedding similarity dominates. +- Signals target domains by heuristic: `GitRepoSignal` boosts any domain whose `top_terms` overlaps `{"rust","async","trait","function","class","def","git","commit","fn","code"}`. `IdeHintSignal` does the same for `{"file","line","editor","vscode","neovim","rust-analyzer","lsp"}`. +- All signal boosts are logged via `tracing::debug!` so users can audit why a memory picked up a domain. + +`GitRepoSignal::boost_map` implementation: + +```rust +fn boost_map(&self, meta: &Value, domains: &[Domain]) -> HashMap { + let is_git = meta.get("cwd") + .and_then(|v| v.as_str()) + .map(|cwd| std::path::Path::new(cwd).join(".git").exists()) + .unwrap_or(false) + || meta.get("git_repo").is_some(); + if !is_git { return HashMap::new(); } + let mut out = HashMap::new(); + for d in domains { + let code_hits = d.top_terms.iter() + .filter(|t| CODE_TERMS.contains(t.as_str())) + .count(); + if code_hits > 0 { out.insert(d.id.clone(), self.boost); } + } + out +} +``` + +Config knob in `[domains.signals]`: `git = true`, `ide = true`, `git_boost = 0.05`, `ide_boost = 0.05`. + +### 8. Cross-domain spreading activation decay + +**File**: `crates/vestige-core/src/neuroscience/spreading_activation.rs` + +Modify `ActivationConfig`: + +```rust +pub struct ActivationConfig { + pub decay_factor: f64, + pub max_hops: u32, + pub min_threshold: f64, + pub allow_cycles: bool, + pub cross_domain_decay: f64, // NEW, default 0.5 +} +``` + +Domain metadata on nodes: the current `ActivationNode` has `id`, `activation`, `last_activated`, `edges: Vec`. Phase 4 adds `pub domains: Vec`. Populated when nodes get added (propagated from the memory's `domains` field). The network is rebuilt on each search from the store; if the in-memory network is persisted (check `ActivationNetwork` lifetime in `CognitiveEngine`), the population happens in the engine at boot and on insert. + +Traversal change, in `ActivationNetwork::activate` loop, replacing the single line `let propagated = current_activation * edge.strength * self.config.decay_factor;`: + +```rust +let cross_penalty = { + let src_doms = self.nodes.get(¤t_id).map(|n| &n.domains); + let tgt_doms = self.nodes.get(&target_id).map(|n| &n.domains); + match (src_doms, tgt_doms) { + (Some(s), Some(t)) if !s.is_empty() && !t.is_empty() => { + let overlap = s.iter().any(|d| t.contains(d)); + if overlap { 1.0 } else { self.config.cross_domain_decay } + } + _ => 1.0, // unclassified on either side: no penalty + } +}; +let propagated = current_activation * edge.strength * self.config.decay_factor * cross_penalty; +``` + +Rationale for "unclassified -> no penalty": unclassified memories are Phase-0 or low-confidence corpus members; penalizing them would block useful cross-pollination during the accumulation ramp. + +API to update a node's domains after reclassification: + +```rust +pub fn set_node_domains(&mut self, id: &str, domains: Vec); +``` + +Called by the reassignment pipeline after `reassign_all`. + +### 9. `vestige.toml` `[domains]` section + +**File**: wherever `vestige.toml` is loaded (search for `[storage]` / `[server]` loaders). Add: + +```toml +[domains] +assign_threshold = 0.65 +discovery_threshold = 150 +recluster_interval = 5 +min_cluster_size = 10 +min_samples = 5 +cross_domain_decay = 0.5 +merge_threshold = 0.90 +top_terms_k = 10 + +[domains.signals] +git = true +ide = true +git_boost = 0.05 +ide_boost = 0.05 +``` + +Rust-side: `DomainsConfig { ... }` struct with `serde(default)` so `vestige.toml` without a `[domains]` section falls back to hard-coded defaults. `DomainClassifier::from_config(cfg: &DomainsConfig) -> Self`. + +### 10. Dashboard UI additions + +**SvelteKit routes** (`apps/dashboard/src/routes/(app)/domains/`): + +- `+page.svelte` (list): fetches `GET /api/v1/domains` and `GET /api/v1/domains/unclassified-count`. Renders a table: `label`, `memories`, `top_terms` chips, `created_at`. Each row links to `/domains/[id]`. A "Discover" button posts `POST /api/v1/domains/discover`. +- `[id]/+page.svelte` (detail): fetches `GET /api/v1/domains/:id`, `GET /api/v1/domains/:id/memories?limit=100`, `GET /api/v1/domains/:id/score-histogram`. Renders: + - Header: label (editable, triggers `PUT /api/v1/domains/:id`), top-terms chips, memory count, created_at. + - Histogram: a vertical bar chart of `domain_scores[:id]` buckets 0-0.1, 0.1-0.2, ..., 0.9-1.0 across all memories. Data source: server precomputes buckets so the client does not need to fetch all scores. + - Memory list: paginated, each row shows the raw score for this domain. +- `proposals/+page.svelte`: fetches `GET /api/v1/domains/proposals?status=pending`. Each pending proposal card shows `kind`, `rationale`, `confidence`, `created_at`, buttons "Accept" (posts `POST /api/v1/domains/proposals/:id/accept`) and "Reject" (`POST .../reject`). Live updates via the existing WebSocket channel (`/ws`) reacting to `DomainProposalCreated` events. + +Styling reuses the existing Tailwind + shadcn-svelte conventions in `apps/dashboard/src/lib/components/`. + +Existing `(app)/stats` and `(app)/feed` pages get a small "Domains" summary panel that links to `/domains`. + +### 11. REST endpoints + +**File**: `crates/vestige-mcp/src/protocol/http.rs` or a new `crates/vestige-mcp/src/api/domains.rs` module, wired into the `/api/v1/` router. + +| Method | Path | Handler | +|--------|------|---------| +| GET | `/api/v1/domains` | `list_domains` -- returns `[Domain...]` + unclassified count | +| POST | `/api/v1/domains/discover` | `trigger_discover` -- body `{ min_cluster_size?: usize, force?: bool }`, returns proposals or applied domains | +| GET | `/api/v1/domains/:id` | `get_domain` | +| PUT | `/api/v1/domains/:id` | `update_domain` -- rename | +| DELETE | `/api/v1/domains/:id` | `delete_domain` -- with `?merge_into=other_id` | +| GET | `/api/v1/domains/:id/memories` | paginated memories in this domain | +| GET | `/api/v1/domains/:id/score-histogram` | precomputed buckets | +| GET | `/api/v1/domains/proposals` | `list_proposals?status=pending` | +| POST | `/api/v1/domains/proposals/:id/accept` | `accept_proposal` | +| POST | `/api/v1/domains/proposals/:id/reject` | `reject_proposal` | + +All handlers go through the Phase 3 auth middleware (Bearer / X-API-Key / session cookie). Responses are JSON; error paths use `StatusCode::*` with a small `{"error": "..."}` body. + +### 12. `domain_proposals` table + trait methods + +Postgres migration (`crates/vestige-core/migrations/postgres/00XX_domain_proposals.sql`): + +```sql +CREATE TABLE domain_proposals ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + kind TEXT NOT NULL, -- 'split' | 'merge' | 'new_cluster' + payload JSONB NOT NULL, -- serialized ProposalKind body + rationale TEXT NOT NULL, + confidence DOUBLE PRECISION NOT NULL, + status TEXT NOT NULL DEFAULT 'pending', -- pending|accepted|rejected + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + resolved_at TIMESTAMPTZ +); +CREATE INDEX idx_domain_proposals_status ON domain_proposals (status, created_at DESC); +``` + +SQLite migration: same table, `UUID` -> `TEXT`, `JSONB` -> `TEXT` with JSON-encoded bodies, `TIMESTAMPTZ` -> `TEXT` ISO-8601. + +`MemoryStore` trait additions: + +```rust +async fn insert_domain_proposal(&self, p: &DomainProposal) -> Result<()>; +async fn list_domain_proposals(&self, status: Option<&str>) -> Result>; +async fn get_domain_proposal(&self, id: &str) -> Result>; +async fn set_proposal_status(&self, id: &str, status: &str) -> Result<()>; +``` + +### 13. WebSocket event for proposals + +**File**: `crates/vestige-mcp/src/dashboard/events.rs` + +Add variant: + +```rust +pub enum VestigeEvent { + // ... existing ... + DomainProposalCreated { + id: String, + kind: String, + confidence: f64, + timestamp: DateTime, + }, + MemoryClassified { + id: String, + domains: Vec, + top_score: f64, + timestamp: DateTime, + }, +} +``` + +The SvelteKit dashboard's WS client reacts to both events: classified events refresh any open domain-detail page; proposal events push a toast and a badge on the navbar. + +--- + +## Test Plan + +Test root: `tests/phase_4/` (a new member of the workspace; mirror the `tests/e2e` layout). + +`tests/phase_4/Cargo.toml`: + +```toml +[package] +name = "vestige-phase4-tests" +version = "0.0.0" +edition = "2024" +publish = false + +[dependencies] +vestige-core = { path = "../../crates/vestige-core", features = ["embeddings", "vector-search", "domain-classification"] } +vestige-mcp = { path = "../../crates/vestige-mcp" } +tokio = { workspace = true } +anyhow = "1" +tempfile = "3" +serde_json = { workspace = true } +uuid = { workspace = true } +``` + +### Unit tests (colocated in `domain_classifier.rs::tests`, `context_signals.rs::tests`, `spreading_activation.rs::tests`) + +Each public function must have at least one test: + +- `classify_empty_domains_returns_empty`: `classify(&[0.0; 768], &[])` returns `ClassificationResult { scores: {}, domains: [] }`. +- `classify_single_domain_scores`: one `Domain` with a known centroid; input embedding equal to centroid; expect score 1.0 and `domains == [id]`. +- `classify_multi_domain_overlap`: two domains A, B; input halfway between centroids; expect both scores >= `assign_threshold`; expect `domains == [A, B]` (order not guaranteed). +- `classify_below_threshold_returns_empty_domains_but_scores_filled`: input orthogonal to all centroids; expect `scores` populated, `domains` empty. +- `classify_with_boost_adds_delta`: same input as above, with `boost = {A: 0.4}`; expect A now above threshold, B unchanged. +- `classify_boost_clamps_to_unit`: `boost = {A: 5.0}`; resulting `scores[A]` must be <= 1.0. +- `tfidf_top_k_returns_distinct_terms`: given three fake docs, `top_k=3` returns three non-duplicate strings, in descending TF-IDF order. +- `tfidf_top_k_drops_stopwords`: `["the and for"]` + real content -> stop-words absent. +- `compute_top_terms_handles_empty_cluster`: returns `vec![]` (no panic). +- `signal_git_present_vs_absent`: `GitRepoSignal` given metadata with `.git` in cwd returns non-empty map; without it returns empty. +- `signal_ide_present_vs_absent`: `IdeHintSignal` ditto for `metadata.editor == "vscode"`. +- `signal_combined_clamped`: two signals both firing each at +0.10 -> combined map values <= +0.15. +- `cross_domain_decay_full_weight_on_overlap`: graph with node A in domain `dev`, node B in domain `dev`, edge A->B strength 1.0; after `activate`, B's activation equals the standard `initial * strength * decay_factor` (no extra penalty). +- `cross_domain_decay_half_weight_no_overlap`: A in `dev`, B in `infra`, same edge -> B's activation is 0.5x that of the overlap case. +- `cross_domain_decay_unclassified_no_penalty`: A classified, B unclassified -> full weight. +- `propose_changes_detects_split`: existing domain `dev`; new discovery returns two clusters whose centroids both sit close to old `dev` centroid, each >= min_cluster_size members -> proposal of kind `Split { parent: "dev", children: [a, b] }`. +- `propose_changes_detects_merge`: two existing domains whose new centroids now have cosine > `merge_threshold` -> proposal of kind `Merge`. +- `propose_changes_detects_new_cluster`: a new cluster with no match >= 0.85 to any existing -> `NewCluster`. +- `apply_proposal_split_updates_memberships`: after accept, memories previously in `dev` get reassigned (some to child a, some to child b) via `reassign_all`. + +### Integration tests (`tests/phase_4/tests/`) + +One file per behavior listed in the Phase 4 acceptance sheet. + +- `discover_seed_corpus.rs` -- loads the 500-memory fixture, runs `classifier.discover(&store).await`, asserts at least 3 clusters, asserts per-cluster intra-similarity mean > 0.6, asserts discovery wall time < 10s in release. Also asserts `top_terms` for each cluster contains at least one expected keyword per cluster (dev: contains any of `rust/trait/async`; infra: `bgp/vlan/network`; home: `solar/battery/pool`). +- `soft_assign_multi_domain.rs` -- inserts a memory "deploy zinit containers over BGP network"; after classify, `domains` contains both `dev` and `infra` (from a known centroid setup). +- `auto_classify_on_ingest.rs` -- with three existing domains, a fresh `smart_ingest` of a dev-ish sentence ends up with `domains == ["dev"]` and non-empty `domain_scores`. +- `reembed_triggers_recluster.rs` -- after `vestige migrate --reembed`, centroids must be recomputed; verify `list_domains()` returns fresh `centroid` values (different from pre-reembed). +- `dream_consolidation_recluster_hook.rs` -- run 5 dream cycles with heavy synthetic memory insertion; after the 5th, assert `list_domain_proposals("pending")` has at least one proposal. +- `proposal_accept_applies_changes.rs` -- accept a split proposal via `apply_proposal`; verify that memories in `dev` are now distributed across the new children and that the old `dev` domain is removed. +- `proposal_reject_leaves_state.rs` -- reject a proposal; verify all domains and memberships unchanged. +- `drift_is_proposal_only.rs` -- over 5 dream cycles with new inserts, never call accept; verify every memory's `domains` field equals its initial post-discovery value. No auto-apply. +- `cross_domain_activation_decay.rs` -- build a `ActivationNetwork` with two memories linked by a strength-1.0 edge, one in `dev`, one in `infra`; activate `dev` memory with 1.0; assert `infra` memory's activation == `0.5 * decay_factor` (0.35 with default decay_factor 0.7). Then set both to `dev` and reassert activation == `0.7`. +- `cli_domains_discover.rs` -- spawn `cargo run -- domains discover --force --json`, parse stdout, assert at least 3 clusters and valid JSON shape. +- `cli_domains_rename_merge.rs` -- happy-path rename then merge, with stdout assertions. +- `context_signal_git_repo.rs` -- ingest the same sentence from inside a tempdir with `.git` vs outside; assert the git-run produces slightly higher `domain_scores` for the code-related domain (diff >= 0.04, matches `git_boost = 0.05`). +- `threshold_tunable.rs` -- same memory, two runs with `assign_threshold = 0.40` vs `0.85`; the low-threshold run assigns more domains than the high-threshold run for the same content. +- `signal_boost_clamped.rs` -- artificially configure `git_boost = 5.0` and assert the resulting per-domain score is still <= 1.0. +- `discover_preserves_stable_ids.rs` -- run discover twice with no new memories; the second run's domain ids match the first's (via centroid-similarity stable-ID matching above 0.85). + +### Dashboard UI tests (`tests/phase_4/ui/`) + +Use curl-driven smoke tests (avoids adding Playwright as a new hard dep; Playwright already exists at `apps/dashboard/playwright.config.ts` and can be extended later). + +- `domains_list_renders.sh` -- `curl -H "X-API-Key: $KEY" http://localhost:3927/api/v1/domains` returns 200 + JSON array with expected keys. +- `domain_detail_histogram.sh` -- `curl .../api/v1/domains/dev/score-histogram` returns 10 buckets. +- `proposal_review_flow.sh` -- create a pending proposal via SQL insert; `curl POST .../api/v1/domains/proposals//accept`; `curl GET .../proposals?status=accepted` shows it. +- `unauth_domain_list_rejected.sh` -- no auth header -> 401. + +### Benchmarks (`tests/phase_4/benches/`) + +Criterion benches: + +- `bench_discover_10k.rs` -- synthetic 10k x 768D embeddings drawn from 5 blobs; assert `discover` wall p95 < 30s on a warm release build. +- `bench_auto_classify_single.rs` -- 20 domains in memory, classify one 768D vector; assert p99 < 5ms. +- `bench_reassign_all.rs` -- 10k memories, 5 domains; assert full `reassign_all` wall time < 90s (100 rows/ms baseline). + +--- + +## Acceptance Criteria + +- [ ] `cargo build -p vestige-core --features domain-classification` zero warnings. +- [ ] `cargo build -p vestige-mcp` zero warnings. +- [ ] `cargo clippy --workspace --all-targets --all-features -- -D warnings` clean. +- [ ] `cargo test -p vestige-phase4-tests` -- all tests in `tests/phase_4/` pass. +- [ ] On a 500+ memory seed corpus covering three natural clusters (dev / infra / home), `vestige domains discover --force` produces sensible top-terms matching the expected keyword sets and labels are stable on a second run. +- [ ] `vestige search` with domain filter `["dev"]` excludes any memory whose `domains` array does not include `dev`. +- [ ] After 5 dream cycles with ongoing inserts, no existing memory's `domains` has silently changed; proposals exist in `domain_proposals` table; accepting a proposal reassigns as described. +- [ ] Cross-domain spreading activation: a query in `dev` that crosses a single edge into an `infra`-only memory still returns the memory but with activation `cross_domain_decay * in-domain_activation`. +- [ ] `vestige domains discover --min-cluster-size 20` produces strictly fewer or equal clusters than the default, and with larger per-cluster membership. +- [ ] Dashboard `/dashboard/domains` route renders all domains within 2 seconds on the seed corpus. +- [ ] Proposal UI flow (open pending, accept, confirmed in store) works end-to-end. +- [ ] Benchmarks meet targets (discover 10k p95 < 30s, auto-classify p99 < 5ms). + +--- + +## Rollback Notes + +- **Feature gate**: add `domain-classification` to `crates/vestige-core/Cargo.toml`'s `[features]`. When disabled, the `DomainClassifier` module is not compiled, the classification call in the ingest path is a no-op (`#[cfg]`-guarded), and cross-domain decay collapses to `1.0`. The CLI `domains` subcommand emits "domain classification is disabled in this build". +- **Revert strategy**: drop the two new tables `domains` (if created in Phase 1 is retained) or `domain_proposals` (Phase 4). A DOWN migration clears `memories.domains` and `memories.domain_scores`. Existing memories simply lose their domain assignments; all search and retrieval paths work unchanged because `domains = []` is the documented "unclassified" state. +- **Idempotency**: rerunning `discover` is always safe. Cluster numeric IDs may differ between runs, but the stable-ID match by centroid similarity preserves user-assigned labels. Do not persist cluster ids in client-side bookmarks; link via the user-assigned label. +- **Data-loss risk**: `apply_proposal` is a destructive operation (it deletes the old parent domain in a split or merges two). The dashboard's accept button double-confirms with a modal that shows the number of affected memories. + +--- + +## Open Implementation Questions + +Each question + candidates + RECOMMENDATION. + +### OQ1. Top-terms extraction: TF-IDF vs BM25 vs frequency? +- TF-IDF with smoothed IDF -- standard, cheap, good-enough. +- BM25 -- better for long-document discrimination, overkill for short memory contents. +- Raw frequency -- noisy; stop-words dominate. +**RECOMMENDATION**: TF-IDF with global IDF over the entire memory corpus (not just cluster members), recomputed once per `discover` call. Same tokenizer as the `dreams.rs::content_similarity` Jaccard for consistency. + +### OQ2. Proposal persistence: DB table vs in-memory with dashboard notification? +- DB table (`domain_proposals`) -- durable, surfaces across restarts, enables audit. +- In-memory only -- simpler, but loses proposals on server restart. +**RECOMMENDATION**: DB table. Proposals are rare (every 5th dream) and valuable user-facing artifacts; durability is mandatory. + +### OQ3. `hdbscan` crate: f32 vs f64 input, exact API surface? +- v0.10 historically takes `&[Vec]`; embeddings are `Vec`. +- Cost of converting f32 -> f64 at discovery time: `10k * 768 = 7.68M` f64 doubles ~ 60MB transient, acceptable. +**RECOMMENDATION**: verify v0.10's type signature at implementation time; if it requires f64, perform the conversion in `discover()` behind a single allocation. Document in module header. If the crate API diverged from the PRD snippet, fall back to the manual builder style (`HdbscanHyperParams::builder().min_cluster_size(n).min_samples(s).build()`). + +### OQ4. Stable domain IDs across discover re-runs? +- Option A: numeric IDs from HDBSCAN labels -- unstable, re-runs shuffle them. +- Option B: hash(top_terms) -- stable if top-terms stable, but top-terms drift. +- Option C (recommended): after computing new centroids, match each to the closest existing domain by centroid cosine; if similarity > 0.85, reuse the existing domain's `id` and `label`. Otherwise mint a fresh `id = "cluster_"`. +**RECOMMENDATION**: Option C. Preserves user-assigned labels across drift. Threshold 0.85 is config-tunable via `stable_id_threshold` if needed later. + +### OQ5. Context signal injection site: ingest handler vs embedder vs classifier? +- Embedder -- would alter embedding; signals are not about embedding quality. +- Ingest handler -- signals known there, but then `DomainClassifier` cannot be tested in isolation. +- Classifier as a `classify_with_boost(boost: Option<&HashMap>)` parameter -- pure, testable, composable. +**RECOMMENDATION**: classifier parameter. The cognitive engine constructs the boost map via `ContextSignals::gather_boost(&metadata, &domains)` and hands it to the classifier. Keeps the classifier stateless w.r.t. signals. + +### OQ6. Re-cluster proposal cadence: event-based (every Nth dream) vs time-based (weekly)? +- ADR resolution Q7: every Nth dream (N=5 default). +- Alternative: once per week regardless of dream cadence. +**RECOMMENDATION**: stick with every Nth dream. Users who dream rarely re-cluster rarely -- that matches the philosophy ("memory work triggers memory bookkeeping"). Note the alternative as future consideration; if users complain about never seeing proposals, add a time-based fallback. + +### OQ7. Minimum corpus size for first discover? +- PRD default: 150. +- Too low -> noisy initial clusters, proposals every dream. +- Too high -> user waits forever for domains to appear. +**RECOMMENDATION**: 150 as the default discovery gate; HDBSCAN's `min_cluster_size=10` will produce 0 clusters for < 100 memories, so the system gracefully produces no domains until the corpus is large enough. Test with `N=80, 150, 500` in `threshold_tunable.rs` to confirm sensible behavior. + +### OQ8. Cross-domain decay: strict no-overlap vs graded? +- Strict: `1.0` if any overlap, `cross_domain_decay` otherwise. +- Graded: `max(cross_domain_decay, |A intersect B| / max(|A|, |B|))`. +**RECOMMENDATION**: strict for Phase 4. Easier to reason about, easier to tune, easier to test. Graded is a marked future enhancement; file an issue if retrieval-quality metrics justify it. + +### OQ9. Classifier invocation from remote HTTP clients? +- In server mode, an agent posts `smart_ingest` -> server embeds -> server classifies. +- All the work stays server-side; MCP clients never do classification. +**RECOMMENDATION**: confirmed server-side-only. Document in the MCP tool schema that `smart_ingest` now returns `domains` and `domain_scores` in its response so clients can display the classification to the user. + +### OQ10. Where to store the dream-cycle counter? +- In-memory on `CognitiveEngine` -- lost on restart, miscounts cadence. +- New `system_state` singleton table. +**RECOMMENDATION**: `system_state` table. Survives restarts. Also useful for future metrics (total memories ever, total dreams ever). + +### OQ11. Scope of `reassign_all` after a proposal accept vs a normal discover? +- On discover --force (first-time), run `reassign_all` against all memories. +- On proposal accept (split / merge), run `reassign_all` only on affected memories (parent's members for split; both parents' members for merge) to avoid touching unrelated records. +**RECOMMENDATION**: scoped reassignment where possible; fall back to full `reassign_all` only on `discover --force` or when the set of domains has fundamentally changed. Reduces write amplification on large corpora. + +### OQ12. Proposal freshness? +- Multiple re-clusters could stack up pending proposals. +**RECOMMENDATION**: before inserting a new proposal, check for existing pending proposals with the same `kind + targets`; if present, bump `created_at` and `confidence` instead of creating a duplicate. Add a `confidence_history` array in the `payload` JSONB for audit. + +--- + +## Implementation Sequencing (suggested order) + +1. Land the `DomainClassifier` struct, `classify` / `classify_with_boost`, unit tests. (Day 1) +2. Add `compute_top_terms` + TF-IDF helper, tests. (Day 1) +3. Wire `discover` end-to-end against SQLite; `discover_seed_corpus` integration test. (Day 2) +4. Add `domain_proposals` table migrations + trait methods; both backends. (Day 2) +5. Implement `propose_changes` + `apply_proposal`; proposal unit tests. (Day 3) +6. Context signals module + tests. (Day 3) +7. Hook classifier into ingest path; `auto_classify_on_ingest` integration test. (Day 4) +8. Cross-domain decay in spreading activation; unit + integration tests. (Day 4) +9. Dream re-cluster hook + `system_state` counter; integration tests for drift-only behavior. (Day 5) +10. CLI subcommands. (Day 6) +11. REST endpoints. (Day 6) +12. SvelteKit dashboard routes + WebSocket event wiring. (Day 7-8) +13. Benchmarks + acceptance sweep on the 500-memory seed. (Day 9) + +--- + +## File Map (everything Phase 4 touches or creates) + +Creates: + +- `crates/vestige-core/src/neuroscience/domain_classifier.rs` +- `crates/vestige-core/src/neuroscience/context_signals.rs` +- `crates/vestige-core/migrations/postgres/00XX_domain_proposals.sql` +- `crates/vestige-core/migrations/sqlite/00XX_domain_proposals.sql` (or inline in `storage/migrations.rs`) +- `crates/vestige-mcp/src/api/domains.rs` (REST handlers) +- `apps/dashboard/src/routes/(app)/domains/+page.svelte` +- `apps/dashboard/src/routes/(app)/domains/[id]/+page.svelte` +- `apps/dashboard/src/routes/(app)/domains/proposals/+page.svelte` +- `apps/dashboard/src/lib/api/domains.ts` +- `tests/phase_4/Cargo.toml` +- `tests/phase_4/tests/*.rs` (per the Integration test list) +- `tests/phase_4/fixtures/seed_500.json` +- `tests/phase_4/support/fixtures.rs` + +Modifies: + +- `crates/vestige-core/Cargo.toml` -- add `hdbscan = "0.10"` under a new `domain-classification` feature. +- `crates/vestige-core/src/neuroscience/mod.rs` -- register new modules, re-exports. +- `crates/vestige-core/src/neuroscience/spreading_activation.rs` -- `cross_domain_decay` field in `ActivationConfig`, `domains` field on `ActivationNode`, decay math in `activate`. +- `crates/vestige-core/src/consolidation/phases.rs` -- `DreamReClusterHook`. +- `crates/vestige-core/src/advanced/dreams.rs` -- accept a hook callback from the orchestrator (if the orchestration is done at this level). +- `crates/vestige-core/src/storage/trait.rs` -- add proposal + system_state methods. +- `crates/vestige-core/src/storage/sqlite.rs` -- implement proposal + system_state methods + `all_embeddings_with_meta` if not already on the trait. +- `crates/vestige-core/src/storage/postgres.rs` (Phase 2) -- same. +- `crates/vestige-core/src/lib.rs` -- re-exports. +- `crates/vestige-core/src/cognitive.rs` (or equivalent ingest orchestrator) -- auto-classify injection. +- `crates/vestige-mcp/src/bin/cli.rs` -- `Domains` subcommand + dispatch. +- `crates/vestige-mcp/src/dashboard/mod.rs` -- wire new REST routes. +- `crates/vestige-mcp/src/dashboard/events.rs` -- new event variants. +- `crates/vestige-mcp/src/dashboard/handlers.rs` -- if legacy dashboard gets a domains panel (optional). +- `vestige.toml` config loader -- `[domains]` section + struct + defaults. +- Root `Cargo.toml` workspace members -- add `tests/phase_4`. + +--- + +## Risks + +- **HDBSCAN determinism**: HDBSCAN is deterministic given input order; sorting embeddings by memory id before feeding the clusterer guarantees reproducibility across runs -- do this in `discover()` and document it. +- **Embedding dimension drift**: Phase 1's `embedding_model` registry blocks writes from mismatched embedders. If `discover()` ever sees two dimensions, it bails with a clear error and points at `vestige migrate --reembed`. +- **Classification latency on ingest**: for users with thousands of domains (unlikely but possible), `classify` is O(n_domains * dim). 20 domains * 768 f32 = 15k flops per classification, trivial. Still, expose a `classify_budget_ms` config knob for paranoia. +- **Re-cluster proposal storms**: if the corpus is borderline-stable, small changes can produce conflicting proposals on consecutive dreams. Mitigation: OQ12 (dedup by target set, bump confidence instead of stacking). +- **Dashboard feature gap**: if the SvelteKit app lands with the domains route but the REST endpoints are not yet deployed, the route 404s. Mitigation: ship the REST endpoints in the same release; a feature flag on the client toggles the nav entry. + +--- + +## Non-Goals Reminder + +- No Phase 5 federation concerns in this plan. +- No cross-installation domain sync. +- No automatic accept of proposals, ever. +- No graded cross-domain decay; strict only. +- No ML-based domain label suggestion (top-terms are enough for v1). +- No editing individual memory memberships from the UI in this phase. diff --git a/docs/prd/001-getting-centralized-vestige.md b/docs/prd/001-getting-centralized-vestige.md new file mode 100644 index 0000000..9d86087 --- /dev/null +++ b/docs/prd/001-getting-centralized-vestige.md @@ -0,0 +1,751 @@ +# RFC: Pluggable Storage Backend + Network Access for Vestige + +**Status**: Draft / Discussion +**Author**: Jan +**Date**: 2026-02-26 +**Vestige version**: v2.x (current main) + +## Summary + +Add a pluggable storage backend trait to Vestige, enabling PostgreSQL (+pgvector) as an alternative to the current SQLite+FTS5+USearch stack. Simultaneously add HTTP MCP transport with API key authentication to enable centralized/remote deployment. + +This keeps the existing local-first SQLite mode fully intact while opening up a server deployment model. + +## Motivation + +Vestige currently runs as a local process per machine (MCP via stdio, SQLite in `~/.vestige/`). This works great for single-machine use but doesn't support: + +- **Multi-machine access**: Same memory brain from laptop, desktop, and server +- **Multi-agent access**: Multiple AI clients hitting one memory store concurrently +- **Future federation**: Syncing memory between decentralized nodes (e.g., MOS/Threefold grid) + +SQLite's single-writer model and lack of native network protocol make it unsuitable as a centralized server. PostgreSQL is a natural fit: built-in concurrency (MVCC), authentication, replication, and with `pgvector` + built-in FTS it collapses three separate storage layers into one. + +## Design + +### Storage Trait + +The core abstraction. All 29 cognitive modules interact with storage exclusively through this trait (or a small family of traits). + +```rust +use std::collections::HashMap; +use uuid::Uuid; + +/// Core memory record, backend-agnostic +#[derive(Debug, Clone)] +pub struct MemoryRecord { + pub id: Uuid, + pub domains: Vec, // [] = unclassified, ["dev"], ["dev", "infra"], etc. + pub domain_scores: HashMap, // raw similarities: {"dev": 0.82, "infra": 0.71} + pub content: String, + pub node_type: String, + pub tags: Vec, + pub embedding: Option>, // dimensionality is runtime config + pub created_at: chrono::DateTime, + pub updated_at: chrono::DateTime, + pub metadata: serde_json::Value, +} + +/// FSRS scheduling state, stored alongside each memory +#[derive(Debug, Clone)] +pub struct SchedulingState { + pub memory_id: Uuid, + pub stability: f64, + pub difficulty: f64, + pub retrievability: f64, + pub last_review: Option>, + pub next_review: Option>, + pub reps: u32, + pub lapses: u32, +} + +/// Hybrid search request +#[derive(Debug, Clone)] +pub struct SearchQuery { + pub domains: Option>, // None = search all domains + pub text: Option, // FTS query + pub embedding: Option>, // vector similarity + pub tags: Option>, // tag filter + pub node_types: Option>, + pub limit: usize, + pub min_retrievability: Option, // filter by FSRS state +} + +#[derive(Debug, Clone)] +pub struct SearchResult { + pub record: MemoryRecord, + pub score: f64, // combined/fused score + pub fts_score: Option, + pub vector_score: Option, +} + +/// Connection/edge between memories (for spreading activation) +#[derive(Debug, Clone)] +pub struct MemoryEdge { + pub source_id: Uuid, + pub target_id: Uuid, + pub edge_type: String, + pub weight: f64, + pub created_at: chrono::DateTime, +} + +/// Main storage trait — one impl per backend +/// trait_variant generates a Send-bound `MemoryStore` alias, +/// enabling Arc without manual boxing. +#[trait_variant::make(MemoryStore: Send)] +pub trait LocalMemoryStore: Sync + 'static { + // --- Lifecycle --- + async fn init(&self) -> Result<()>; + async fn health_check(&self) -> Result; + + // --- CRUD --- + async fn insert(&self, record: &MemoryRecord) -> Result; + async fn get(&self, id: Uuid) -> Result>; + async fn update(&self, record: &MemoryRecord) -> Result<()>; + async fn delete(&self, id: Uuid) -> Result<()>; + + // --- Search --- + async fn search(&self, query: &SearchQuery) -> Result>; + async fn fts_search(&self, text: &str, limit: usize) -> Result>; + async fn vector_search(&self, embedding: &[f32], limit: usize) -> Result>; + + // --- FSRS Scheduling --- + async fn get_scheduling(&self, memory_id: Uuid) -> Result>; + async fn update_scheduling(&self, state: &SchedulingState) -> Result<()>; + async fn get_due_memories(&self, before: chrono::DateTime, limit: usize) -> Result>; + + // --- Graph (spreading activation) --- + async fn add_edge(&self, edge: &MemoryEdge) -> Result<()>; + async fn get_edges(&self, node_id: Uuid, edge_type: Option<&str>) -> Result>; + async fn remove_edge(&self, source: Uuid, target: Uuid) -> Result<()>; + async fn get_neighbors(&self, node_id: Uuid, depth: usize) -> Result>; + + // --- Bulk / Maintenance --- + async fn count(&self) -> Result; + async fn get_stats(&self) -> Result; + async fn vacuum(&self) -> Result<()>; +} +``` + +**Design notes:** + +- `trait_variant::make` generates a `MemoryStore` trait alias with `Send`-bound futures, allowing `Arc` for runtime backend selection. `LocalMemoryStore` is the base (usable in single-threaded contexts), `MemoryStore` is the Send variant for Axum/tokio. +- `embedding: Option>` — dimensions determined at runtime by the configured fastembed model. The backend stores whatever it gets. +- The trait is intentionally flat. The cognitive modules (FSRS-6, spreading activation, synaptic tagging, prediction error gating, etc.) sit *above* this trait and don't need to know about the backend. +- `search()` does hybrid RRF fusion at the backend level — both SQLite and Postgres implementations handle this internally. + +### Backend: SQLite (existing, refactored) + +Wraps the current implementation behind the trait: + +``` +SqliteMemoryStore +├── rusqlite connection pool (r2d2 or deadpool) +├── FTS5 virtual table (keyword search) +├── USearch HNSW index (vector search, behind RwLock) +└── WAL mode + busy timeout for concurrent readers +``` + +No behavioral changes — just the trait boundary. + +### Backend: PostgreSQL (new) + +``` +PgMemoryStore +├── sqlx::PgPool (connection pool, compile-time checked queries) +├── tsvector + GIN index (keyword search) +├── pgvector + HNSW index (vector search) +└── Standard PostgreSQL MVCC concurrency +``` + +**Schema sketch:** + +```sql +CREATE EXTENSION IF NOT EXISTS vector; + +-- Domain registry — populated by clustering, not by user +CREATE TABLE domains ( + id TEXT PRIMARY KEY, -- auto-generated or user-named + label TEXT NOT NULL, -- human label (suggested or user-provided) + centroid vector, -- mean embedding of domain members + top_terms TEXT[] NOT NULL DEFAULT '{}', -- top keywords for display + memory_count INTEGER NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + metadata JSONB NOT NULL DEFAULT '{}' +); + +CREATE TABLE memories ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + domains TEXT[] NOT NULL DEFAULT '{}', -- [] = unclassified + domain_scores JSONB NOT NULL DEFAULT '{}', -- {"dev": 0.82, "infra": 0.71} raw similarities + content TEXT NOT NULL, + node_type TEXT NOT NULL DEFAULT 'general', + tags TEXT[] NOT NULL DEFAULT '{}', + embedding vector, -- dimension set at table creation or unconstrained + metadata JSONB NOT NULL DEFAULT '{}', + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), + + -- FTS: auto-maintained tsvector column + search_vec TSVECTOR GENERATED ALWAYS AS ( + setweight(to_tsvector('english', content), 'A') || + setweight(to_tsvector('english', coalesce(node_type, '')), 'B') || + setweight(array_to_tsvector(tags), 'C') + ) STORED +); + +-- FTS index +CREATE INDEX idx_memories_fts ON memories USING GIN (search_vec); + +-- Vector similarity (HNSW) +CREATE INDEX idx_memories_embedding ON memories + USING hnsw (embedding vector_cosine_ops) + WITH (m = 16, ef_construction = 64); + +-- Common filters +CREATE INDEX idx_memories_domains ON memories USING GIN (domains); +CREATE INDEX idx_memories_node_type ON memories (node_type); +CREATE INDEX idx_memories_tags ON memories USING GIN (tags); +CREATE INDEX idx_memories_created ON memories (created_at); + +-- FSRS scheduling state +CREATE TABLE scheduling ( + memory_id UUID PRIMARY KEY REFERENCES memories(id) ON DELETE CASCADE, + stability DOUBLE PRECISION NOT NULL DEFAULT 0.0, + difficulty DOUBLE PRECISION NOT NULL DEFAULT 0.0, + retrievability DOUBLE PRECISION NOT NULL DEFAULT 1.0, + last_review TIMESTAMPTZ, + next_review TIMESTAMPTZ, + reps INTEGER NOT NULL DEFAULT 0, + lapses INTEGER NOT NULL DEFAULT 0 +); + +CREATE INDEX idx_scheduling_next ON scheduling (next_review); + +-- Graph edges (spreading activation) +-- Edges can cross domain boundaries — spreading activation respects +-- domain filters when provided, traverses freely when searching all domains. +CREATE TABLE edges ( + source_id UUID NOT NULL REFERENCES memories(id) ON DELETE CASCADE, + target_id UUID NOT NULL REFERENCES memories(id) ON DELETE CASCADE, + edge_type TEXT NOT NULL DEFAULT 'related', + weight DOUBLE PRECISION NOT NULL DEFAULT 1.0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (source_id, target_id, edge_type) +); + +CREATE INDEX idx_edges_target ON edges (target_id); + +-- API keys +CREATE TABLE api_keys ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + key_hash TEXT NOT NULL UNIQUE, -- blake3 + label TEXT NOT NULL, + scopes TEXT[] NOT NULL DEFAULT '{read,write}', + domain_filter TEXT[] NOT NULL DEFAULT '{}', -- {} = access all domains + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + last_used TIMESTAMPTZ, + active BOOLEAN NOT NULL DEFAULT true +); +``` + +**Hybrid search in SQL:** + +```sql +-- RRF (Reciprocal Rank Fusion) combining FTS + vector +-- $1 = query text, $2 = embedding, $3 = limit, $4 = domain filter (NULL for all) +WITH fts AS ( + SELECT id, ts_rank_cd(search_vec, websearch_to_tsquery('english', $1)) AS score, + ROW_NUMBER() OVER (ORDER BY ts_rank_cd(search_vec, websearch_to_tsquery('english', $1)) DESC) AS rank + FROM memories + WHERE search_vec @@ websearch_to_tsquery('english', $1) + AND ($4::text[] IS NULL OR domains && $4) -- array overlap: any match + LIMIT 50 +), +vec AS ( + SELECT id, 1 - (embedding <=> $2::vector) AS score, + ROW_NUMBER() OVER (ORDER BY embedding <=> $2::vector) AS rank + FROM memories + WHERE embedding IS NOT NULL + AND ($4::text[] IS NULL OR domains && $4) + LIMIT 50 +) +SELECT COALESCE(f.id, v.id) AS id, + COALESCE(1.0 / (60 + f.rank), 0) + COALESCE(1.0 / (60 + v.rank), 0) AS rrf_score, + f.score AS fts_score, + v.score AS vector_score +FROM fts f FULL OUTER JOIN vec v ON f.id = v.id +ORDER BY rrf_score DESC +LIMIT $3; +``` + +### Embedding Configuration + +The embedding layer stays external to the storage backend. fastembed runs locally and produces vectors that get passed into `MemoryRecord.embedding`. + +```toml +# vestige.toml +[embeddings] +provider = "fastembed" # only local for now +model = "BAAI/bge-base-en-v1.5" # 768 dimensions +# model = "BAAI/bge-large-en-v1.5" # 1024 dimensions +# model = "BAAI/bge-small-en-v1.5" # 384 dimensions + +[storage] +backend = "postgres" # or "sqlite" + +[storage.sqlite] +path = "~/.vestige/vestige.db" + +[storage.postgres] +url = "postgresql://vestige:secret@localhost:5432/vestige" +max_connections = 10 +``` + +On init, the backend reads the embedding dimension from the first stored vector (or from config) and validates consistency. + +For pgvector: you can either create the column as `vector(768)` (fixed, faster) or unconstrained `vector` (flexible, slightly slower). Recommendation: fixed dimension derived from config, with a migration path if the model changes. + +### Emergent Domain Model + +Instead of user-defined tenants, domains emerge automatically from the data via clustering. The user never has to decide where a memory belongs — the system figures it out. + +#### Pipeline + +``` +Phase 1: Accumulate (cold start, 0 → N memories) +│ All memories stored with domains = [] (unclassified) +│ No classification overhead, just embed and store +│ Threshold N is configurable, default ~150 memories +│ +Phase 2: Discover (triggered once at threshold, or manually) +│ Run HDBSCAN on all embeddings: +│ - min_cluster_size: ~10 +│ - min_samples: ~5 +│ - No eps parameter needed (unlike DBSCAN) +│ - Automatically determines number of clusters +│ - Handles variable-density clusters +│ - Border points between clusters flagged naturally +│ +│ For each cluster, extract: +│ - Centroid (mean embedding) +│ - Top terms (TF-IDF or frequency over cluster members) +│ - Suggested label from top terms +│ +│ Present to user (via dashboard or CLI): +│ "I found 3 natural groupings in your memories: +│ ● cluster_0 (47 memories): BGP, SONiC, VLAN, FRR, peering... +│ ● cluster_1 (31 memories): solar, kWh, battery, pool, ESPHome... +│ ● cluster_2 (22 memories): Rust, trait, async, zinit, tokio..." +│ +│ User can: +│ - Name them: cluster_0 → "infra", cluster_1 → "home", cluster_2 → "dev" +│ - Accept suggested names +│ - Merge clusters +│ - Do nothing (auto-names stick) +│ +Phase 3: Soft-assign all existing memories +│ Now that centroids exist, re-score every memory (including +│ those from discovery) against all centroids. +│ This replaces HDBSCAN's hard labels with continuous scores: +│ +│ For each memory: +│ similarities = [(domain, cosine_sim(embedding, centroid)) for each domain] +│ domains = [id for (id, score) in similarities if score >= threshold] +│ +│ Memories in overlap zones get multiple domains. +│ Memories far from all centroids stay unclassified. +│ +Phase 4: Classify (ongoing, after discovery) +│ New memory ingested: +│ 1. Compute embedding +│ 2. Compute similarity to ALL domain centroids +│ 3. Store raw scores in domain_scores JSONB +│ 4. Threshold into domains[] array +│ 5. Update domain centroids incrementally (running mean) +│ +│ Context signals as soft priors: +│ - Git repo / IDE metadata → boost similarity to code-related domains +│ - No workspace context → slight boost toward non-technical domains +│ - These shift the score, never override the embedding distance +│ +Phase 5: Re-cluster (periodic, during dream consolidation) + Re-run HDBSCAN on all embeddings including new ones + Detect: + - New clusters forming from previously unclassified memories + - Existing clusters splitting (domain grew too broad) + - Clusters merging (domains that were artificially separate) + Propose changes to user: + "Your 'dev' domain may have split into two groups: + - systems (zinit, MOS, containers, VMs) — 34 memories + - networking (BGP, SONiC, VLANs, MLAG) — 28 memories + Split them? [yes / no / later]" + Re-run soft assignment on all memories after structural changes + Centroid vectors are updated regardless +``` + +#### Domain Storage + +```rust +#[derive(Debug, Clone)] +pub struct Domain { + pub id: String, + pub label: String, + pub centroid: Vec, + pub top_terms: Vec, + pub memory_count: usize, + pub created_at: chrono::DateTime, +} +``` + +Added to the `MemoryStore` trait: + +```rust + // --- Domains --- + async fn list_domains(&self) -> Result>; + async fn get_domain(&self, id: &str) -> Result>; + async fn upsert_domain(&self, domain: &Domain) -> Result<()>; + async fn delete_domain(&self, id: &str) -> Result<()>; + async fn classify(&self, embedding: &[f32]) -> Result>; + // Returns [(domain_id, similarity)] sorted by similarity desc. + // Caller decides threshold for assignment. +``` + +#### Classification Module + +A new cognitive module alongside FSRS, spreading activation, etc.: + +```rust +pub struct DomainClassifier { + /// Similarity threshold — domains scoring above this are assigned + pub assign_threshold: f64, // default: 0.65 + /// Minimum memories before running initial discovery + pub discovery_threshold: usize, // default: 150 + /// How often to re-cluster (in dream consolidation passes) + pub recluster_interval: usize, // default: every 5th consolidation + /// HDBSCAN min_cluster_size + pub min_cluster_size: usize, // default: 10 +} + +/// Raw classification result — all scores, before thresholding +#[derive(Debug, Clone)] +pub struct ClassificationResult { + /// Similarity to every known domain centroid + pub scores: HashMap, // {"dev": 0.82, "infra": 0.71, "home": 0.34} + /// Domains above assign_threshold + pub domains: Vec, // ["dev", "infra"] +} + +impl DomainClassifier { + /// Score a memory against all domain centroids. + /// Returns raw scores AND thresholded domain list. + pub fn classify( + &self, + embedding: &[f32], + domains: &[Domain], + ) -> ClassificationResult { + if domains.is_empty() { + return ClassificationResult { + scores: HashMap::new(), + domains: vec![], // still in accumulation phase + }; + } + + let scores: HashMap = domains.iter() + .map(|d| (d.id.clone(), cosine_similarity(embedding, &d.centroid))) + .collect(); + + let assigned: Vec = scores.iter() + .filter(|(_, &s)| s >= self.assign_threshold) + .map(|(id, _)| id.clone()) + .collect(); + + ClassificationResult { scores, domains: assigned } + } + + /// Soft-assign all existing memories after discovery or re-clustering. + /// Returns number of memories whose domains changed. + pub async fn reassign_all( + &self, + store: &dyn MemoryStore, + domains: &[Domain], + ) -> Result { + // Load all memories, re-score, update domains + domain_scores + // Batched to avoid loading everything into memory at once + todo!() + } +} +``` + +**Key distinction from the previous design:** there's no "closest wins" or "margin" logic. Every domain gets a score, and *all* domains above threshold are assigned. A memory about "deploying zinit containers via BGP-routed network" might score 0.78 on "dev" and 0.72 on "infra" — it gets both. A memory about "solar panel output today" scores 0.85 on "home" and 0.31 on everything else — it only gets "home". + +The raw `domain_scores` are always stored, so you (or the dashboard) can see *why* a memory was classified the way it was, and the threshold can be adjusted retroactively without re-computing embeddings. + +#### Search Behavior + +- **Default (no domain filter)**: searches all memories across all domains +- **Domain-scoped**: `domains: Some(vec!["dev"])` — only memories tagged with `dev` +- **Multi-domain**: `domains: Some(vec!["dev", "infra"])` — memories in either +- **MCP clients can set `X-Vestige-Domain` header** for default scoping, but the system works fine without it + +#### HDBSCAN Implementation + +HDBSCAN (Hierarchical DBSCAN) over the embedding vectors. Advantages over plain DBSCAN: + +- **No `eps` parameter** — the hardest thing to tune in DBSCAN. HDBSCAN determines density thresholds from the data hierarchy. +- **Variable-density clusters** — a tight cluster of networking memories and a spread-out cluster of personal memories are both detected correctly. +- **Border points** — memories between clusters are identified as low-confidence members, which aligns perfectly with soft assignment. + +Implementation: the `hdbscan` crate in Rust. Load all embeddings into memory (at 768d × f32 × 10k memories ≈ 30MB — fine), cluster, compute centroids, soft-assign all memories against the centroids. + +```rust +use hdbscan::{Center, Hdbscan}; + +fn discover_domains( + embeddings: &[Vec], + min_cluster_size: usize, +) -> (Vec>, Vec>) { // (cluster → member indices, centroids) + let clusterer = Hdbscan::default(embeddings); + let labels = clusterer.cluster().unwrap(); + let centroids = clusterer.calc_centers(Center::Centroid, &labels).unwrap(); + + // Group indices by label, ignoring noise (-1) + let mut clusters: HashMap> = HashMap::new(); + for (i, &label) in labels.iter().enumerate() { + if label >= 0 { + clusters.entry(label).or_default().push(i); + } + } + (clusters.into_values().collect(), centroids) +} +``` + +After HDBSCAN produces hard clusters, the soft-assignment pass (Phase 3) immediately re-scores all memories — including the ones HDBSCAN assigned — against the computed centroids. So HDBSCAN's hard labels are only used to *define* the centroids. The actual domain assignments always come from the continuous similarity scores. + +This works identically for both SQLite and Postgres backends — clustering runs in Rust application code, results are written back to the storage layer. + +### Network Transport + +#### MCP over Streamable HTTP + +Extend the existing Axum server: + +```rust +// Alongside existing dashboard routes +let app = Router::new() + // Existing dashboard + .route("/api/health", get(health_handler)) + .route("/dashboard/*path", get(dashboard_handler)) + // New: MCP over HTTP + .route("/mcp", post(mcp_handler).get(mcp_sse_handler)) + // New: REST API + // X-Vestige-Domain header optionally scopes to a domain + .route("/api/v1/memories", post(create_memory).get(list_memories)) + .route("/api/v1/memories/:id", get(get_memory).put(update_memory).delete(delete_memory)) + .route("/api/v1/search", post(search_memories)) + .route("/api/v1/consolidate", post(trigger_consolidation)) + .route("/api/v1/stats", get(get_stats)) + .route("/api/v1/domains", get(list_domains)) + .route("/api/v1/domains/discover", post(trigger_discovery)) + .route("/api/v1/domains/:id", put(rename_domain).delete(merge_domain)) + // Auth on everything except health + .layer(middleware::from_fn(api_key_auth)); +``` + +#### Auth Middleware + +```rust +async fn api_key_auth( + State(store): State>, + request: axum::extract::Request, + next: middleware::Next, +) -> Result { + // Skip auth for health endpoint + if request.uri().path() == "/api/health" { + return Ok(next.run(request).await); + } + + let key = request.headers() + .get("Authorization") + .and_then(|v| v.to_str().ok()) + .and_then(|v| v.strip_prefix("Bearer ")) + .or_else(|| request.headers() + .get("X-API-Key") + .and_then(|v| v.to_str().ok())); + + match key { + Some(k) if verify_api_key(store.as_ref(), k).await => { + Ok(next.run(request).await) + } + _ => Err(StatusCode::UNAUTHORIZED), + } +} +``` + +#### Client Configuration + +```json +// Claude Desktop / Claude Code — single key, all domains +{ + "mcpServers": { + "vestige": { + "url": "http://vestige.local:3927/mcp", + "headers": { + "Authorization": "Bearer vst_a1b2c3..." + } + } + } +} +``` + +No domain header needed — searches all domains by default. The MCP tools include an optional `domain` parameter for scoped queries if the LLM or user wants to narrow down. + +Alternatively, scope a connection to a specific domain: + +```json +// Domain-scoped connection (e.g., for a home automation agent) +{ + "mcpServers": { + "vestige-home": { + "url": "http://vestige.local:3927/mcp", + "headers": { + "Authorization": "Bearer vst_e5f6g7...", + "X-Vestige-Domain": "home" + } + } + } +} +``` + +### Server Configuration + +```toml +# vestige.toml — full example for server mode +[server] +bind = "0.0.0.0:3927" # or mycelium IPv6 address +# tls_cert = "/path/to/cert.pem" # optional +# tls_key = "/path/to/key.pem" + +[auth] +enabled = true +# If false, no key required (local-only mode) + +[storage] +backend = "postgres" + +[storage.postgres] +url = "postgresql://vestige:secret@localhost:5432/vestige" +max_connections = 10 + +[embeddings] +provider = "fastembed" +model = "BAAI/bge-base-en-v1.5" +``` + +### CLI Extensions + +```bash +# Domain management (mostly automatic, but user can inspect/rename) +vestige domains list +# → dev Development (auto) memories: 87 top: Rust, trait, async, tokio +# → infra Infrastructure (auto) memories: 47 top: BGP, SONiC, VLAN, FRR +# → home Home (auto) memories: 31 top: solar, kWh, pool, ESPHome +# → (unclassified) memories: 12 + +vestige domains rename cluster_0 infra --label "Infrastructure" +vestige domains merge home personal --into home +vestige domains discover --force # re-run HDBSCAN now + +# Key management +vestige keys create --label "macbook" +# → Created key: vst_a1b2c3d4... (store this, shown once) + +vestige keys create --label "home-assistant" --scopes read --domains home +# → Created key: vst_e5f6g7h8... (read-only, home domain only) + +vestige keys list +# → macbook vst_a1b2... scopes: [read,write] domains: [all] +# → home-assistant vst_e5f6... scopes: [read] domains: [home] + +vestige keys revoke vst_a1b2c3d4... + +# Migration +vestige migrate --from sqlite --to postgres \ + --sqlite-path ~/.vestige/vestige.db \ + --postgres-url postgresql://localhost/vestige +``` + +## Implementation Plan + +### Phase 1: Storage Trait Extraction +- Define the `MemoryStore` trait (including domain methods) +- Refactor current SQLite code to implement it +- Add `domains TEXT[]` column to existing SQLite schema +- Verify all 29 modules work through the trait (no direct SQLite access) +- **No behavioral changes** — all memories start as unclassified + +### Phase 2: PostgreSQL Backend +- Implement `PgMemoryStore` +- Schema migrations (sqlx or refinery) +- `vestige migrate` command for SQLite → Postgres +- Config file support for backend selection + +### Phase 3: Network Access +- MCP Streamable HTTP endpoint on existing Axum server +- API key auth middleware + CLI management +- REST API endpoints +- Feature flags for stdio vs HTTP mode + +### Phase 4: Emergent Domain Classification +- `DomainClassifier` cognitive module +- HDBSCAN clustering via `hdbscan` crate (runs on both backends) +- Soft assignment pass: score all memories against centroids, threshold into domains +- `domain_scores` JSONB stored per memory for transparency / retroactive re-thresholding +- Domain discovery CLI and dashboard UI +- Auto-classification on ingest (once domains exist) +- Re-clustering during dream consolidation passes +- Domain management CLI (rename, merge, inspect) + +### Phase 5: Federation (future) +- Node discovery via Mycelium / mDNS +- Memory sync protocol (UUID-based, last-write-wins) +- Possibly Iroh for content-addressed replication +- FSRS state merge (review history append, not overwrite) + +## Crate Dependencies (new) + +```toml +# Phase 1 — trait abstraction +trait-variant = "0.1" + +# Phase 2 — Postgres +sqlx = { version = "0.8", features = ["runtime-tokio", "postgres", "uuid", "chrono", "json"] } +pgvector = "0.4" # sqlx integration for vector type + +# Phase 3 — Auth +blake3 = "1" # key hashing +rand = "0.8" # key generation + +# Phase 4 — Domain clustering +hdbscan = "0.10" # HDBSCAN — no eps tuning, variable density, built-in centroid calc +``` + +## Open Questions + +1. **Trait granularity**: One big `MemoryStore` trait or split into `MemoryStore + SchedulingStore + GraphStore + DomainStore`? Splitting is cleaner but means more `dyn` parameters threading through handlers. + +2. **Embedding on insert**: Should the storage backend call fastembed, or should the caller always provide the embedding? Current design says caller provides it, keeping the backend pure storage. But this means every client needs fastembed locally even if the DB is remote. For the server model, having the server compute embeddings makes more sense. + +3. **pgvector dimension**: Fixed (e.g., `vector(768)`) or unconstrained (`vector`)? Fixed is faster for HNSW but requires migration if model changes. + +4. **Sync conflict resolution for federation**: LWW per-UUID is simple but lossy. CRDTs would be more correct but massively more complex. For FSRS state specifically, merging review event logs would be ideal. + +5. **Dashboard auth**: The 3D dashboard currently runs unauthenticated on localhost. With remote access, it needs the same auth. Should it use the same API keys or have a separate session/cookie mechanism? + +6. **HDBSCAN `min_cluster_size`**: The main tuning knob. Too small → noisy micro-clusters. Too large → distinct topics get merged. Default of 10 should work for most cases, but may need a manual override or auto-sweep (run with several values, pick the one with best silhouette score). + +7. **Domain drift**: Over time, the character of a domain changes. How aggressively should re-clustering reshape existing domains? Conservative (only propose splits/merges, never auto-apply) vs. aggressive (auto-reassign memories whose scores drifted below threshold)? + +8. **Spreading activation across domains**: When searching within a single domain, should graph edges that cross into other domains be followed? Probably yes for recall quality, but with decaying weight as you cross boundaries. + +9. **Threshold tuning**: The `assign_threshold` (0.65 default) determines how many memories are multi-domain vs single-domain vs unclassified. Too low → everything is multi-domain (useless). Too high → too many unclassified. Could be auto-tuned per dataset by targeting a specific unclassified ratio (e.g., "keep fewer than 10% unclassified"). From 9c633c172b346980eacd5173e5aa66eea767836a Mon Sep 17 00:00:00 2001 From: Jan De Landtsheer Date: Wed, 22 Apr 2026 10:28:59 +0200 Subject: [PATCH 02/23] Added postgres admin added amends to the postgres backend/phase2 --- .gitignore | 3 + docs/plans/0002-phase-2-postgres-backend.md | 3 +- docs/plans/local-dev-postgres-setup.md | 153 ++++++++++++++++++++ 3 files changed, 158 insertions(+), 1 deletion(-) create mode 100644 docs/plans/local-dev-postgres-setup.md diff --git a/.gitignore b/.gitignore index 4236e68..41e352a 100644 --- a/.gitignore +++ b/.gitignore @@ -137,3 +137,6 @@ apps/dashboard/node_modules/ # ============================================================================= fastembed-rs/ .mcp.json + +.claude/ +.codebase-memory/ diff --git a/docs/plans/0002-phase-2-postgres-backend.md b/docs/plans/0002-phase-2-postgres-backend.md index a372e27..3fe28f2 100644 --- a/docs/plans/0002-phase-2-postgres-backend.md +++ b/docs/plans/0002-phase-2-postgres-backend.md @@ -2,7 +2,7 @@ **Status**: Draft **Depends on**: Phase 1 (MemoryStore + Embedder traits, embedding_model registry, domain columns) -**Related**: docs/adr/0001-pluggable-storage-and-network-access.md (Phase 2), docs/prd/001-getting-centralized-vestige.md +**Related**: docs/adr/0001-pluggable-storage-and-network-access.md (Phase 2), docs/prd/001-getting-centralized-vestige.md, docs/plans/local-dev-postgres-setup.md (local cluster provisioning) --- @@ -85,6 +85,7 @@ postgres-backend = ["dep:sqlx", "dep:pgvector", "dep:tokio-stream", "dep:futures - The `pgvector` extension installed in the target database (our migration issues `CREATE EXTENSION IF NOT EXISTS vector`). - `sqlx-cli@0.8` installed on the developer machine for `cargo sqlx prepare --workspace` and `cargo sqlx migrate add` (not a build-time requirement once `.sqlx/` is committed). - Docker or Podman reachable by the test harness for `testcontainers-modules::postgres` to spin up `pgvector/pgvector:pg16`. +- A local Postgres cluster for `sqlx prepare`, manual migration work, and `vestige migrate --to postgres` smoke runs. The recipe for standing one up on Arch/CachyOS (install, initdb, role + db, pgvector, connection string at `~/.vestige_pg_pw`) lives in `docs/plans/local-dev-postgres-setup.md`. Postgres 18 from the Arch repo satisfies the "16 or newer" requirement above. Phase 2 work assumes `DATABASE_URL` points at that cluster once migrations are applied. ### Assumed Rust toolchain diff --git a/docs/plans/local-dev-postgres-setup.md b/docs/plans/local-dev-postgres-setup.md new file mode 100644 index 0000000..6250a55 --- /dev/null +++ b/docs/plans/local-dev-postgres-setup.md @@ -0,0 +1,153 @@ +# Local Dev Postgres Setup (Arch / CachyOS) + +**Status**: Applied on this machine on 2026-04-21 +**Related**: docs/plans/0002-phase-2-postgres-backend.md, docs/adr/0001-pluggable-storage-and-network-access.md + +Purpose: capture the minimum, repeatable steps to stand up a Postgres 18 instance on a local Arch/CachyOS box for Phase 2 (`PgMemoryStore`) development, `sqlx prepare`, and manual migration testing. This is a single-operator dev recipe, not a production runbook. + +--- + +## Current state on this machine + +- Package: `postgresql` 18.3-2 (pacman). Pulls `postgresql-libs`, `libxslt`. +- Service: `postgresql.service`, enabled + active. +- Listens on: `127.0.0.1:5432` and `[::1]:5432` only (default `listen_addresses = 'localhost'`). +- Data dir: `/var/lib/postgres/data`, owner `postgres:postgres`. +- Auth (`pg_hba.conf`, Arch defaults): `peer` for local socket, `scram-sha-256` for host 127.0.0.1/::1. + +### Database + role + +- Database: `vestige`, UTF8, owner `vestige`. +- Role: `vestige` with `LOGIN CREATEDB` (no superuser, no replication, no cross-db). +- Schema `public` re-owned to `vestige`, plus default privileges so any future tables / sequences / functions in `public` are fully owned and granted to `vestige`. + +Net effect: the `vestige` role can create, alter, drop, and grant freely inside the `vestige` database -- enough for `sqlx::migrate!`, ad-hoc schema work, and the full Phase 2 `MemoryStore` surface. It cannot create extensions (see Phase 2 followups below) and cannot touch other databases. + +### Connection + +``` +postgresql://vestige:@127.0.0.1:5432/vestige +``` + +Password lives at `~/.vestige_pg_pw`, mode 600, owned by the dev user (no sudo needed to read it). Read with: + +```sh +cat ~/.vestige_pg_pw +``` + +Recommended dev shell export (keep this OUT of the repo; use `.env` + gitignore or a shell rc): + +```sh +export DATABASE_URL="postgresql://vestige:$(cat ~/.vestige_pg_pw)@127.0.0.1:5432/vestige" +``` + +--- + +## Reproduce from scratch + +On a fresh Arch / CachyOS box with passwordless sudo: + +```sh +# 1. Install +sudo pacman -S --noconfirm postgresql + +# 2. Initialize the cluster (UTF8, scram-sha-256 for host, peer for local) +sudo -iu postgres initdb \ + --locale=C.UTF-8 --encoding=UTF8 \ + -D /var/lib/postgres/data \ + --auth-host=scram-sha-256 --auth-local=peer + +# 3. Start + enable +sudo systemctl enable --now postgresql + +# 4. Generate a password and stash it in the dev user's home (mode 600) +VESTIGE_PW=$(python3 -c 'import secrets,string; a=string.ascii_letters+string.digits; print("".join(secrets.choice(a) for _ in range(32)))') +umask 077 +printf '%s' "$VESTIGE_PW" > ~/.vestige_pg_pw +chmod 600 ~/.vestige_pg_pw + +# 5. Create role + database + grants +sudo -u postgres psql -v ON_ERROR_STOP=1 < ~/.vestige_pg_pw +chmod 600 ~/.vestige_pg_pw +sudo -u postgres psql -v ON_ERROR_STOP=1 \ + -c "ALTER ROLE vestige WITH PASSWORD '${NEW_PW}';" +unset NEW_PW +``` + +Then re-export `DATABASE_URL` in any live shells. + +--- + +## Teardown + +Destroys the cluster and all data in it: + +```sh +sudo systemctl disable --now postgresql +sudo pacman -Rns postgresql postgresql-libs +sudo rm -rf /var/lib/postgres +rm -f ~/.vestige_pg_pw +``` + +--- + +## Out of scope for this doc + +- TLS, client-cert auth, non-localhost access. Phase 3 exposes the Vestige HTTP API over the network, not Postgres directly. +- Backups, PITR, WAL archiving. For dev data: `pg_dump -h 127.0.0.1 -U vestige vestige > vestige.sql`. +- Replication, PgBouncer, tuned `postgresql.conf`. Defaults are fine for Phase 2 development. +- Making this the canonical Vestige backend. By default Vestige still uses SQLite; this cluster exists so the `postgres-backend` feature can be built and tested locally. From 1399329810211a76bd4f6624cf65cb84ed08831c Mon Sep 17 00:00:00 2001 From: Sam Valladares <143034159+samvallad33@users.noreply.github.com> Date: Mon, 25 May 2026 01:44:52 -0500 Subject: [PATCH 03/23] Release v2.1.22 Sanhedrin receipts (#55) --- CHANGELOG.md | 22 + Cargo.lock | 4 +- Cargo.toml | 2 +- README.md | 13 + .../_app/immutable/assets/0.CN9L-NIY.css | 1 + .../_app/immutable/assets/0.CN9L-NIY.css.br | Bin 0 -> 10353 bytes .../_app/immutable/assets/0.CN9L-NIY.css.gz | Bin 0 -> 12348 bytes .../_app/immutable/assets/0.IIz8MMYb.css | 1 - .../_app/immutable/assets/0.IIz8MMYb.css.br | Bin 9720 -> 0 bytes .../_app/immutable/assets/0.IIz8MMYb.css.gz | Bin 11661 -> 0 bytes .../chunks/{DNjM5a-l.js => 554JRhq6.js} | 2 +- .../_app/immutable/chunks/554JRhq6.js.br | Bin 0 -> 632 bytes .../_app/immutable/chunks/554JRhq6.js.gz | Bin 0 -> 756 bytes .../_app/immutable/chunks/BTwePnbx.js.br | Bin 7668 -> 0 bytes .../_app/immutable/chunks/BTwePnbx.js.gz | Bin 8428 -> 0 bytes .../_app/immutable/chunks/BdslOLCg.js.br | Bin 2609 -> 0 bytes .../_app/immutable/chunks/BdslOLCg.js.gz | Bin 2953 -> 0 bytes .../build/_app/immutable/chunks/BjdL4Pm2.js | 1 - .../_app/immutable/chunks/BjdL4Pm2.js.br | Bin 1513 -> 0 bytes .../_app/immutable/chunks/BjdL4Pm2.js.gz | Bin 1645 -> 0 bytes .../chunks/{DzfRjky4.js => CcUbQ_Wl.js} | 2 +- .../_app/immutable/chunks/CcUbQ_Wl.js.br | Bin 0 -> 340 bytes .../_app/immutable/chunks/CcUbQ_Wl.js.gz | Bin 0 -> 407 bytes .../chunks/{BTwePnbx.js => D-gDZzN6.js} | 2 +- .../_app/immutable/chunks/D-gDZzN6.js.br | Bin 0 -> 7644 bytes .../_app/immutable/chunks/D-gDZzN6.js.gz | Bin 0 -> 8427 bytes .../build/_app/immutable/chunks/D4ymNiig.js | 1 + .../_app/immutable/chunks/D4ymNiig.js.br | Bin 0 -> 1616 bytes .../_app/immutable/chunks/D4ymNiig.js.gz | Bin 0 -> 1770 bytes .../chunks/{BdslOLCg.js => DGcYlAAw.js} | 2 +- .../_app/immutable/chunks/DGcYlAAw.js.br | Bin 0 -> 2609 bytes .../_app/immutable/chunks/DGcYlAAw.js.gz | Bin 0 -> 2953 bytes .../_app/immutable/chunks/DNjM5a-l.js.br | Bin 580 -> 0 bytes .../_app/immutable/chunks/DNjM5a-l.js.gz | Bin 700 -> 0 bytes .../_app/immutable/chunks/DzfRjky4.js.br | Bin 321 -> 0 bytes .../_app/immutable/chunks/DzfRjky4.js.gz | Bin 387 -> 0 bytes .../{app.DRELdRUq.js => app.BIXcLtMB.js} | 4 +- .../_app/immutable/entry/app.BIXcLtMB.js.br | Bin 0 -> 3574 bytes .../_app/immutable/entry/app.BIXcLtMB.js.gz | Bin 0 -> 4071 bytes .../_app/immutable/entry/app.DRELdRUq.js.br | Bin 3563 -> 0 bytes .../_app/immutable/entry/app.DRELdRUq.js.gz | Bin 4067 -> 0 bytes .../_app/immutable/entry/start.Bnkotnxp.js | 1 + .../_app/immutable/entry/start.Bnkotnxp.js.br | Bin 0 -> 108 bytes .../_app/immutable/entry/start.Bnkotnxp.js.gz | Bin 0 -> 107 bytes .../_app/immutable/entry/start.DfC8txIX.js | 1 - .../_app/immutable/entry/start.DfC8txIX.js.br | Bin 114 -> 0 bytes .../_app/immutable/entry/start.DfC8txIX.js.gz | Bin 107 -> 0 bytes .../build/_app/immutable/nodes/0.BSxKGxRx.js | 86 +++ .../_app/immutable/nodes/0.BSxKGxRx.js.br | Bin 0 -> 9644 bytes .../_app/immutable/nodes/0.BSxKGxRx.js.gz | Bin 0 -> 10974 bytes .../build/_app/immutable/nodes/0._nbDJIPC.js | 86 --- .../_app/immutable/nodes/0._nbDJIPC.js.br | Bin 8174 -> 0 bytes .../_app/immutable/nodes/0._nbDJIPC.js.gz | Bin 9316 -> 0 bytes .../_app/immutable/nodes/1.Bnre2dw5.js.br | Bin 334 -> 0 bytes .../_app/immutable/nodes/1.Bnre2dw5.js.gz | Bin 378 -> 0 bytes .../nodes/{1.Bnre2dw5.js => 1.CJFfVX1H.js} | 2 +- .../_app/immutable/nodes/1.CJFfVX1H.js.br | Bin 0 -> 339 bytes .../_app/immutable/nodes/1.CJFfVX1H.js.gz | Bin 0 -> 383 bytes .../_app/immutable/nodes/10.CecvzcnA.js.br | Bin 124143 -> 0 bytes .../_app/immutable/nodes/10.CecvzcnA.js.gz | Bin 148776 -> 0 bytes .../nodes/{10.CecvzcnA.js => 10.CjP_ylq3.js} | 2 +- .../_app/immutable/nodes/10.CjP_ylq3.js.br | Bin 0 -> 124081 bytes .../_app/immutable/nodes/10.CjP_ylq3.js.gz | Bin 0 -> 148779 bytes .../_app/immutable/nodes/11.BbfUOvv5.js.br | Bin 4831 -> 0 bytes .../_app/immutable/nodes/11.BbfUOvv5.js.gz | Bin 5415 -> 0 bytes .../nodes/{11.BbfUOvv5.js => 11.k15P8M2H.js} | 2 +- .../_app/immutable/nodes/11.k15P8M2H.js.br | Bin 0 -> 4827 bytes .../_app/immutable/nodes/11.k15P8M2H.js.gz | Bin 0 -> 5417 bytes .../nodes/{12.DaxyVsV4.js => 12.BthmSU_R.js} | 2 +- .../_app/immutable/nodes/12.BthmSU_R.js.br | Bin 0 -> 2402 bytes .../_app/immutable/nodes/12.BthmSU_R.js.gz | Bin 0 -> 2710 bytes .../_app/immutable/nodes/12.DaxyVsV4.js.br | Bin 2401 -> 0 bytes .../_app/immutable/nodes/12.DaxyVsV4.js.gz | Bin 2709 -> 0 bytes .../nodes/{13.D52bbIQQ.js => 13.C0fh4g_5.js} | 2 +- .../_app/immutable/nodes/13.C0fh4g_5.js.br | Bin 0 -> 5193 bytes .../_app/immutable/nodes/13.C0fh4g_5.js.gz | Bin 0 -> 5915 bytes .../_app/immutable/nodes/13.D52bbIQQ.js.br | Bin 5188 -> 0 bytes .../_app/immutable/nodes/13.D52bbIQQ.js.gz | Bin 5914 -> 0 bytes .../_app/immutable/nodes/15.C7Fk4d1G.js.br | Bin 7443 -> 0 bytes .../_app/immutable/nodes/15.C7Fk4d1G.js.gz | Bin 8511 -> 0 bytes .../nodes/{15.C7Fk4d1G.js => 15.QNRJhGzj.js} | 2 +- .../_app/immutable/nodes/15.QNRJhGzj.js.br | Bin 0 -> 7442 bytes .../_app/immutable/nodes/15.QNRJhGzj.js.gz | Bin 0 -> 8512 bytes .../_app/immutable/nodes/16.DeYkCVEo.js.br | Bin 5699 -> 0 bytes .../_app/immutable/nodes/16.DeYkCVEo.js.gz | Bin 6455 -> 0 bytes .../nodes/{16.DeYkCVEo.js => 16.QhdtMP78.js} | 2 +- .../_app/immutable/nodes/16.QhdtMP78.js.br | Bin 0 -> 5681 bytes .../_app/immutable/nodes/16.QhdtMP78.js.gz | Bin 0 -> 6455 bytes .../_app/immutable/nodes/17.CLL0vjL4.js.br | Bin 3391 -> 0 bytes .../_app/immutable/nodes/17.CLL0vjL4.js.gz | Bin 3853 -> 0 bytes .../nodes/{17.CLL0vjL4.js => 17.DlzXJVdF.js} | 2 +- .../_app/immutable/nodes/17.DlzXJVdF.js.br | Bin 0 -> 3392 bytes .../_app/immutable/nodes/17.DlzXJVdF.js.gz | Bin 0 -> 3853 bytes .../nodes/{18.CXHHR36X.js => 18.Bmu4OWRV.js} | 2 +- .../_app/immutable/nodes/18.Bmu4OWRV.js.br | Bin 0 -> 2023 bytes .../_app/immutable/nodes/18.Bmu4OWRV.js.gz | Bin 0 -> 2265 bytes .../_app/immutable/nodes/18.CXHHR36X.js.br | Bin 2025 -> 0 bytes .../_app/immutable/nodes/18.CXHHR36X.js.gz | Bin 2265 -> 0 bytes .../nodes/{19.D4UHDxxJ.js => 19.Baocji37.js} | 2 +- .../_app/immutable/nodes/19.Baocji37.js.br | Bin 0 -> 1550 bytes .../_app/immutable/nodes/19.Baocji37.js.gz | Bin 0 -> 1755 bytes .../_app/immutable/nodes/19.D4UHDxxJ.js.br | Bin 1553 -> 0 bytes .../_app/immutable/nodes/19.D4UHDxxJ.js.gz | Bin 1755 -> 0 bytes .../_app/immutable/nodes/20.BM_Hn1tR.js.br | Bin 5511 -> 0 bytes .../_app/immutable/nodes/20.BM_Hn1tR.js.gz | Bin 6452 -> 0 bytes .../nodes/{20.BM_Hn1tR.js => 20.CJQuAMkU.js} | 2 +- .../_app/immutable/nodes/20.CJQuAMkU.js.br | Bin 0 -> 5512 bytes .../_app/immutable/nodes/20.CJQuAMkU.js.gz | Bin 0 -> 6454 bytes .../_app/immutable/nodes/3.De3LPrRR.js.br | Bin 164 -> 0 bytes .../_app/immutable/nodes/3.De3LPrRR.js.gz | Bin 197 -> 0 bytes .../nodes/{3.De3LPrRR.js => 3.mK8D6pz1.js} | 2 +- .../_app/immutable/nodes/3.mK8D6pz1.js.br | Bin 0 -> 165 bytes .../_app/immutable/nodes/3.mK8D6pz1.js.gz | Bin 0 -> 198 bytes .../_app/immutable/nodes/4.DJCab_le.js.br | Bin 4438 -> 0 bytes .../_app/immutable/nodes/4.DJCab_le.js.gz | Bin 4976 -> 0 bytes .../nodes/{4.DJCab_le.js => 4.DPhwyLUO.js} | 2 +- .../_app/immutable/nodes/4.DPhwyLUO.js.br | Bin 0 -> 4437 bytes .../_app/immutable/nodes/4.DPhwyLUO.js.gz | Bin 0 -> 4976 bytes .../nodes/{6.BN-BfASZ.js => 6.BD0AetaD.js} | 2 +- .../_app/immutable/nodes/6.BD0AetaD.js.br | Bin 0 -> 5625 bytes .../_app/immutable/nodes/6.BD0AetaD.js.gz | Bin 0 -> 6335 bytes .../_app/immutable/nodes/6.BN-BfASZ.js.br | Bin 5620 -> 0 bytes .../_app/immutable/nodes/6.BN-BfASZ.js.gz | Bin 6334 -> 0 bytes .../nodes/{7.jHtvjgRi.js => 7.2YrTacps.js} | 2 +- .../_app/immutable/nodes/7.2YrTacps.js.br | Bin 0 -> 4942 bytes .../_app/immutable/nodes/7.2YrTacps.js.gz | Bin 0 -> 5685 bytes .../_app/immutable/nodes/7.jHtvjgRi.js.br | Bin 4943 -> 0 bytes .../_app/immutable/nodes/7.jHtvjgRi.js.gz | Bin 5686 -> 0 bytes .../_app/immutable/nodes/8.CgPowUzz.js.br | Bin 3015 -> 0 bytes .../_app/immutable/nodes/8.CgPowUzz.js.gz | Bin 3485 -> 0 bytes .../nodes/{8.CgPowUzz.js => 8.CokrlgDp.js} | 2 +- .../_app/immutable/nodes/8.CokrlgDp.js.br | Bin 0 -> 3017 bytes .../_app/immutable/nodes/8.CokrlgDp.js.gz | Bin 0 -> 3487 bytes .../_app/immutable/nodes/9.BWaJ-VBd.js.br | Bin 2951 -> 0 bytes .../_app/immutable/nodes/9.BWaJ-VBd.js.gz | Bin 3347 -> 0 bytes .../nodes/{9.BWaJ-VBd.js => 9.Vu2AXN40.js} | 2 +- .../_app/immutable/nodes/9.Vu2AXN40.js.br | Bin 0 -> 2949 bytes .../_app/immutable/nodes/9.Vu2AXN40.js.gz | Bin 0 -> 3345 bytes apps/dashboard/build/_app/version.json | 2 +- apps/dashboard/build/_app/version.json.br | 2 +- apps/dashboard/build/_app/version.json.gz | Bin 40 -> 40 bytes apps/dashboard/build/index.html | 14 +- apps/dashboard/build/index.html.br | Bin 605 -> 608 bytes apps/dashboard/build/index.html.gz | Bin 792 -> 791 bytes apps/dashboard/package-lock.json | 4 +- apps/dashboard/package.json | 2 +- .../src/lib/components/InsightToast.svelte | 3 +- .../src/lib/components/VerdictBar.svelte | 327 +++++++++ apps/dashboard/src/lib/stores/api.ts | 16 +- apps/dashboard/src/lib/stores/toast.ts | 19 + apps/dashboard/src/lib/types/index.ts | 60 ++ apps/dashboard/src/routes/+layout.svelte | 2 + crates/vestige-core/Cargo.toml | 2 +- crates/vestige-mcp/Cargo.toml | 4 +- crates/vestige-mcp/src/autopilot.rs | 1 + crates/vestige-mcp/src/dashboard/events.rs | 10 + crates/vestige-mcp/src/dashboard/handlers.rs | 325 +++++++++ crates/vestige-mcp/src/dashboard/mod.rs | 3 + hooks/sanhedrin-local.py | 155 ++++- hooks/sanhedrin.sh | 42 +- hooks/sanhedrin_core.py | 623 ++++++++++++++++++ package.json | 2 +- packages/vestige-init/package.json | 2 +- packages/vestige-mcp-npm/package.json | 2 +- packages/vestige-mcpb/README.md | 4 +- packages/vestige-mcpb/build.sh | 2 +- packages/vestige-mcpb/manifest.json | 2 +- server.json | 4 +- tests/hooks/test_sanhedrin_claim_mode.py | 64 ++ 169 files changed, 1815 insertions(+), 148 deletions(-) create mode 100644 apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css create mode 100644 apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css.br create mode 100644 apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css.gz delete mode 100644 apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css delete mode 100644 apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css.br delete mode 100644 apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css.gz rename apps/dashboard/build/_app/immutable/chunks/{DNjM5a-l.js => 554JRhq6.js} (86%) create mode 100644 apps/dashboard/build/_app/immutable/chunks/554JRhq6.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/554JRhq6.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/chunks/BTwePnbx.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/BTwePnbx.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/chunks/BdslOLCg.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/BdslOLCg.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js delete mode 100644 apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js.gz rename apps/dashboard/build/_app/immutable/chunks/{DzfRjky4.js => CcUbQ_Wl.js} (52%) create mode 100644 apps/dashboard/build/_app/immutable/chunks/CcUbQ_Wl.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/CcUbQ_Wl.js.gz rename apps/dashboard/build/_app/immutable/chunks/{BTwePnbx.js => D-gDZzN6.js} (76%) create mode 100644 apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.gz create mode 100644 apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js create mode 100644 apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js.gz rename apps/dashboard/build/_app/immutable/chunks/{BdslOLCg.js => DGcYlAAw.js} (74%) create mode 100644 apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/chunks/DzfRjky4.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/DzfRjky4.js.gz rename apps/dashboard/build/_app/immutable/entry/{app.DRELdRUq.js => app.BIXcLtMB.js} (77%) create mode 100644 apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.br create mode 100644 apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/entry/app.DRELdRUq.js.br delete mode 100644 apps/dashboard/build/_app/immutable/entry/app.DRELdRUq.js.gz create mode 100644 apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js create mode 100644 apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.br create mode 100644 apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/entry/start.DfC8txIX.js delete mode 100644 apps/dashboard/build/_app/immutable/entry/start.DfC8txIX.js.br delete mode 100644 apps/dashboard/build/_app/immutable/entry/start.DfC8txIX.js.gz create mode 100644 apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js create mode 100644 apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js delete mode 100644 apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/1.Bnre2dw5.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/1.Bnre2dw5.js.gz rename apps/dashboard/build/_app/immutable/nodes/{1.Bnre2dw5.js => 1.CJFfVX1H.js} (80%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CecvzcnA.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CecvzcnA.js.gz rename apps/dashboard/build/_app/immutable/nodes/{10.CecvzcnA.js => 10.CjP_ylq3.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/11.BbfUOvv5.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/11.BbfUOvv5.js.gz rename apps/dashboard/build/_app/immutable/nodes/{11.BbfUOvv5.js => 11.k15P8M2H.js} (98%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/11.k15P8M2H.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/11.k15P8M2H.js.gz rename apps/dashboard/build/_app/immutable/nodes/{12.DaxyVsV4.js => 12.BthmSU_R.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/12.BthmSU_R.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/12.BthmSU_R.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/12.DaxyVsV4.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/12.DaxyVsV4.js.gz rename apps/dashboard/build/_app/immutable/nodes/{13.D52bbIQQ.js => 13.C0fh4g_5.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/13.C0fh4g_5.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/13.C0fh4g_5.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/13.D52bbIQQ.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/13.D52bbIQQ.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/15.C7Fk4d1G.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/15.C7Fk4d1G.js.gz rename apps/dashboard/build/_app/immutable/nodes/{15.C7Fk4d1G.js => 15.QNRJhGzj.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/15.QNRJhGzj.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/15.QNRJhGzj.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/16.DeYkCVEo.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/16.DeYkCVEo.js.gz rename apps/dashboard/build/_app/immutable/nodes/{16.DeYkCVEo.js => 16.QhdtMP78.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/16.QhdtMP78.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/16.QhdtMP78.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/17.CLL0vjL4.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/17.CLL0vjL4.js.gz rename apps/dashboard/build/_app/immutable/nodes/{17.CLL0vjL4.js => 17.DlzXJVdF.js} (98%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/17.DlzXJVdF.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/17.DlzXJVdF.js.gz rename apps/dashboard/build/_app/immutable/nodes/{18.CXHHR36X.js => 18.Bmu4OWRV.js} (98%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/18.Bmu4OWRV.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/18.Bmu4OWRV.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/18.CXHHR36X.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/18.CXHHR36X.js.gz rename apps/dashboard/build/_app/immutable/nodes/{19.D4UHDxxJ.js => 19.Baocji37.js} (96%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/19.Baocji37.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/19.Baocji37.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/19.D4UHDxxJ.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/19.D4UHDxxJ.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/20.BM_Hn1tR.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/20.BM_Hn1tR.js.gz rename apps/dashboard/build/_app/immutable/nodes/{20.BM_Hn1tR.js => 20.CJQuAMkU.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/3.De3LPrRR.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/3.De3LPrRR.js.gz rename apps/dashboard/build/_app/immutable/nodes/{3.De3LPrRR.js => 3.mK8D6pz1.js} (56%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js.gz rename apps/dashboard/build/_app/immutable/nodes/{4.DJCab_le.js => 4.DPhwyLUO.js} (98%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.gz rename apps/dashboard/build/_app/immutable/nodes/{6.BN-BfASZ.js => 6.BD0AetaD.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js.gz rename apps/dashboard/build/_app/immutable/nodes/{7.jHtvjgRi.js => 7.2YrTacps.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/7.2YrTacps.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/7.2YrTacps.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/7.jHtvjgRi.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/7.jHtvjgRi.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/8.CgPowUzz.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/8.CgPowUzz.js.gz rename apps/dashboard/build/_app/immutable/nodes/{8.CgPowUzz.js => 8.CokrlgDp.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/9.BWaJ-VBd.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/9.BWaJ-VBd.js.gz rename apps/dashboard/build/_app/immutable/nodes/{9.BWaJ-VBd.js => 9.Vu2AXN40.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/9.Vu2AXN40.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/9.Vu2AXN40.js.gz create mode 100644 apps/dashboard/src/lib/components/VerdictBar.svelte create mode 100644 hooks/sanhedrin_core.py diff --git a/CHANGELOG.md b/CHANGELOG.md index f0dc778..f6825cb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +## [2.1.22] - 2026-05-25 — "Sanhedrin Receipts" + +v2.1.22 makes the optional Sanhedrin hook quieter and more accountable by +turning draft judgment into local, appealable receipts instead of opaque vetoes. + +### Added + +- **Receipt Lock** blocks unsupported verification claims such as "tests passed" + unless the current transcript contains a matching successful test, build, + lint, or typecheck command receipt. +- **Veto receipts** are written to `~/.vestige/sanhedrin/latest.json` and + `latest.html` with Claim -> Verdict -> Precedent -> Fix -> Appeal fields. +- **Dashboard Verdict Bar** surfaces the latest PASS, NOTE, CAUTION, VETO, or + APPEALED state and lets users appeal stale, wrong, or too-strict vetoes. +- **Appeal training** records feedback in `appeals.jsonl` and suppresses future + vetoes for the same claim fingerprint. + +### Changed + +- Sanhedrin claim-mode output now feeds a per-claim receipt ledger while keeping + the existing one-line Stop-hook contract for Claude Code. + ## [2.1.21] - 2026-05-24 — "Agent-Neutral Hardening" v2.1.21 is a release-hardening pass for normal MCP usage across agents. It keeps diff --git a/Cargo.lock b/Cargo.lock index 3e2e19d..70f3956 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4531,7 +4531,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "vestige-core" -version = "2.1.21" +version = "2.1.22" dependencies = [ "candle-core", "chrono", @@ -4567,7 +4567,7 @@ dependencies = [ [[package]] name = "vestige-mcp" -version = "2.1.21" +version = "2.1.22" dependencies = [ "anyhow", "axum", diff --git a/Cargo.toml b/Cargo.toml index f5d2eb3..5cbe508 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,7 @@ exclude = [ ] [workspace.package] -version = "2.1.21" +version = "2.1.22" edition = "2024" license = "AGPL-3.0-only" repository = "https://github.com/samvallad33/vestige" diff --git a/README.md b/README.md index 8fb70f2..3c18759 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,19 @@ Built on proven memory and retrieval ideas — FSRS-6 spaced repetition, predict --- +## What's New in v2.1.22 "Sanhedrin Receipts" + +v2.1.22 makes the optional Sanhedrin hook accountable enough to trust in daily +agent work. Vetoes now leave local receipts, verification claims need real +command evidence, and users can appeal stale or over-strict blocks from the +dashboard. + +- **Receipt Lock.** Claims like "tests passed", "build is green", or "lint is clean" are blocked unless the current transcript contains a matching successful command receipt. +- **Screenshotable veto receipts.** Sanhedrin writes `~/.vestige/sanhedrin/latest.json` and `latest.html` with Claim -> Verdict -> Precedent -> Fix -> Appeal. +- **Dashboard Verdict Bar.** The dashboard shows PASS, NOTE, CAUTION, VETO, or APPEALED globally, expands into the receipt, and records stale/wrong/too-strict appeals. +- **Claim ledger.** Claim-mode Sanhedrin output now maps every extracted claim into structured JSON instead of treating the whole draft as one blob. +- **Appeal training.** Appeals are saved to `appeals.jsonl` and suppress future vetoes for the same claim fingerprint. + ## What's New in v2.1.21 "Agent-Neutral Hardening" v2.1.21 tightens Vestige for normal use across MCP-compatible agents, without diff --git a/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css b/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css new file mode 100644 index 0000000..b0b4d99 --- /dev/null +++ b/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css @@ -0,0 +1 @@ +/*! tailwindcss v4.2.0 | MIT License | https://tailwindcss.com */@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--font-mono:"JetBrains Mono", "Fira Code", "SF Mono", monospace;--color-amber-400:oklch(82.8% .189 84.429);--color-purple-400:oklch(71.4% .203 305.504);--color-purple-500:oklch(62.7% .265 303.9);--color-black:#000;--color-white:#fff;--spacing:.25rem;--container-xs:20rem;--container-md:28rem;--container-lg:32rem;--container-xl:36rem;--container-2xl:42rem;--container-4xl:56rem;--container-5xl:64rem;--container-6xl:72rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height: 1.5 ;--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--text-3xl:1.875rem;--text-3xl--line-height: 1.2 ;--text-4xl:2.25rem;--text-4xl--line-height:calc(2.5 / 2.25);--text-5xl:3rem;--text-5xl--line-height:1;--text-6xl:3.75rem;--text-6xl--line-height:1;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--tracking-tight:-.025em;--tracking-wide:.025em;--tracking-wider:.05em;--tracking-widest:.1em;--leading-snug:1.375;--leading-relaxed:1.625;--radius-sm:.25rem;--radius-md:.375rem;--radius-lg:.5rem;--radius-xl:.75rem;--radius-2xl:1rem;--ease-out:cubic-bezier(0, 0, .2, 1);--ease-in-out:cubic-bezier(.4, 0, .2, 1);--animate-spin:spin 1s linear infinite;--animate-ping:ping 1s cubic-bezier(0, 0, .2, 1) infinite;--animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--blur-sm:8px;--blur-md:12px;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono);--color-void:#050510;--color-abyss:#0a0a1a;--color-deep:#10102a;--color-surface:#161638;--color-elevated:#1e1e4a;--color-subtle:#2a2a5e;--color-muted:#4a4a7a;--color-dim:#7a7aaa;--color-text:#e0e0ff;--color-bright:#fff;--color-synapse:#6366f1;--color-synapse-glow:#818cf8;--color-dream:#a855f7;--color-dream-glow:#c084fc;--color-memory:#3b82f6;--color-recall:#10b981;--color-decay:#ef4444;--color-warning:#f59e0b;--color-node-pattern:#ec4899}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;-moz-tab-size:4;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){-webkit-appearance:button;-moz-appearance:button;appearance:button}::file-selector-button{-webkit-appearance:button;-moz-appearance:button;appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}}@layer components;@layer utilities{.pointer-events-auto{pointer-events:auto}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.sticky{position:sticky}.inset-0{inset:calc(var(--spacing) * 0)}.inset-x-0{inset-inline:calc(var(--spacing) * 0)}.start{inset-inline-start:var(--spacing)}.end{inset-inline-end:var(--spacing)}.end\!{inset-inline-end:var(--spacing)!important}.top-0{top:calc(var(--spacing) * 0)}.top-0\.5{top:calc(var(--spacing) * .5)}.top-1{top:calc(var(--spacing) * 1)}.top-3{top:calc(var(--spacing) * 3)}.top-4{top:calc(var(--spacing) * 4)}.top-10{top:calc(var(--spacing) * 10)}.right-0{right:calc(var(--spacing) * 0)}.right-4{right:calc(var(--spacing) * 4)}.bottom-0{bottom:calc(var(--spacing) * 0)}.bottom-4{bottom:calc(var(--spacing) * 4)}.-left-\[29px\]{left:-29px}.left-1\/2{left:50%}.left-4{left:calc(var(--spacing) * 4)}.left-6{left:calc(var(--spacing) * 6)}.isolate{isolation:isolate}.z-10{z-index:10}.z-20{z-index:20}.z-40{z-index:40}.z-50{z-index:50}.z-\[1\]{z-index:1}.container{width:100%}@media(min-width:40rem){.container{max-width:40rem}}@media(min-width:48rem){.container{max-width:48rem}}@media(min-width:64rem){.container{max-width:64rem}}@media(min-width:80rem){.container{max-width:80rem}}@media(min-width:96rem){.container{max-width:96rem}}.mx-2{margin-inline:calc(var(--spacing) * 2)}.mx-auto{margin-inline:auto}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:calc(var(--spacing) * 1)}.mt-1\.5{margin-top:calc(var(--spacing) * 1.5)}.mt-2{margin-top:calc(var(--spacing) * 2)}.mt-3{margin-top:calc(var(--spacing) * 3)}.mt-4{margin-top:calc(var(--spacing) * 4)}.mt-\[-12px\]{margin-top:-12px}.mr-1{margin-right:calc(var(--spacing) * 1)}.mr-2{margin-right:calc(var(--spacing) * 2)}.mb-0\.5{margin-bottom:calc(var(--spacing) * .5)}.mb-1{margin-bottom:calc(var(--spacing) * 1)}.mb-1\.5{margin-bottom:calc(var(--spacing) * 1.5)}.mb-2{margin-bottom:calc(var(--spacing) * 2)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.mb-4{margin-bottom:calc(var(--spacing) * 4)}.ml-2{margin-left:calc(var(--spacing) * 2)}.ml-3{margin-left:calc(var(--spacing) * 3)}.ml-auto{margin-left:auto}.line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-4{-webkit-line-clamp:4;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.block{display:block}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-flex{display:inline-flex}.table{display:table}.aspect-square{aspect-ratio:1}.h-0\.5{height:calc(var(--spacing) * .5)}.h-1{height:calc(var(--spacing) * 1)}.h-1\.5{height:calc(var(--spacing) * 1.5)}.h-2{height:calc(var(--spacing) * 2)}.h-2\.5{height:calc(var(--spacing) * 2.5)}.h-3{height:calc(var(--spacing) * 3)}.h-4{height:calc(var(--spacing) * 4)}.h-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-12{height:calc(var(--spacing) * 12)}.h-14{height:calc(var(--spacing) * 14)}.h-16{height:calc(var(--spacing) * 16)}.h-20{height:calc(var(--spacing) * 20)}.h-24{height:calc(var(--spacing) * 24)}.h-28{height:calc(var(--spacing) * 28)}.h-32{height:calc(var(--spacing) * 32)}.h-40{height:calc(var(--spacing) * 40)}.h-\[520px\]{height:520px}.h-\[560px\]{height:560px}.h-full{height:100%}.h-px{height:1px}.h-screen{height:100vh}.max-h-48{max-height:calc(var(--spacing) * 48)}.max-h-64{max-height:calc(var(--spacing) * 64)}.max-h-72{max-height:calc(var(--spacing) * 72)}.max-h-96{max-height:calc(var(--spacing) * 96)}.max-h-\[620px\]{max-height:620px}.min-h-0{min-height:calc(var(--spacing) * 0)}.min-h-40{min-height:calc(var(--spacing) * 40)}.min-h-\[240px\]{min-height:240px}.min-h-\[320px\]{min-height:320px}.min-h-\[520px\]{min-height:520px}.min-h-full{min-height:100%}.w-1\.5{width:calc(var(--spacing) * 1.5)}.w-2{width:calc(var(--spacing) * 2)}.w-2\.5{width:calc(var(--spacing) * 2.5)}.w-3{width:calc(var(--spacing) * 3)}.w-4{width:calc(var(--spacing) * 4)}.w-5{width:calc(var(--spacing) * 5)}.w-6{width:calc(var(--spacing) * 6)}.w-7{width:calc(var(--spacing) * 7)}.w-8{width:calc(var(--spacing) * 8)}.w-9{width:calc(var(--spacing) * 9)}.w-12{width:calc(var(--spacing) * 12)}.w-14{width:calc(var(--spacing) * 14)}.w-16{width:calc(var(--spacing) * 16)}.w-20{width:calc(var(--spacing) * 20)}.w-24{width:calc(var(--spacing) * 24)}.w-32{width:calc(var(--spacing) * 32)}.w-96{width:calc(var(--spacing) * 96)}.w-\[3px\]{width:3px}.w-\[90\%\]{width:90%}.w-full{width:100%}.w-px{width:1px}.max-w-2xl{max-width:var(--container-2xl)}.max-w-4xl{max-width:var(--container-4xl)}.max-w-5xl{max-width:var(--container-5xl)}.max-w-6xl{max-width:var(--container-6xl)}.max-w-7xl{max-width:var(--container-7xl)}.max-w-20{max-width:calc(var(--spacing) * 20)}.max-w-\[220px\]{max-width:220px}.max-w-lg{max-width:var(--container-lg)}.max-w-md{max-width:var(--container-md)}.max-w-xl{max-width:var(--container-xl)}.max-w-xs{max-width:var(--container-xs)}.min-w-0{min-width:calc(var(--spacing) * 0)}.min-w-12{min-width:calc(var(--spacing) * 12)}.min-w-16{min-width:calc(var(--spacing) * 16)}.min-w-64{min-width:calc(var(--spacing) * 64)}.min-w-\[2rem\]{min-width:2rem}.min-w-\[3\.5rem\]{min-width:3.5rem}.flex-1{flex:1}.flex-shrink{flex-shrink:1}.flex-shrink-0{flex-shrink:0}.shrink{flex-shrink:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.border-separate{border-collapse:separate}.-translate-x-1\/2{--tw-translate-x: -50% ;translate:var(--tw-translate-x) var(--tw-translate-y)}.scale-125{--tw-scale-x:125%;--tw-scale-y:125%;--tw-scale-z:125%;scale:var(--tw-scale-x) var(--tw-scale-y)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.animate-\[fadeSlide_0\.35s_ease-out_both\]{animation:.35s ease-out both fadeSlide}.animate-ping{animation:var(--animate-ping)}.animate-pulse{animation:var(--animate-pulse)}.animate-spin{animation:var(--animate-spin)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.resize{resize:both}.resize-none{resize:none}.resize-y{resize:vertical}.appearance-none{-webkit-appearance:none;-moz-appearance:none;appearance:none}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.grid-cols-7{grid-template-columns:repeat(7,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-baseline{align-items:baseline}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-around{justify-content:space-around}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.gap-0{gap:calc(var(--spacing) * 0)}.gap-0\.5{gap:calc(var(--spacing) * .5)}.gap-1{gap:calc(var(--spacing) * 1)}.gap-1\.5{gap:calc(var(--spacing) * 1.5)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}.gap-4{gap:calc(var(--spacing) * 4)}.gap-5{gap:calc(var(--spacing) * 5)}.gap-6{gap:calc(var(--spacing) * 6)}.gap-\[2px\]{gap:2px}:where(.space-y-0\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * .5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * .5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1.5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1.5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 4) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 4) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 6) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-8>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 8) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 8) * calc(1 - var(--tw-space-y-reverse)))}.gap-x-6{column-gap:calc(var(--spacing) * 6)}.gap-y-1{row-gap:calc(var(--spacing) * 1)}.self-center{align-self:center}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:var(--radius-2xl)}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius-lg)}.rounded-md{border-radius:var(--radius-md)}.rounded-sm{border-radius:var(--radius-sm)}.rounded-xl{border-radius:var(--radius-xl)}.rounded-t{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.border{border-style:var(--tw-border-style);border-width:1px}.border-2{border-style:var(--tw-border-style);border-width:2px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.\!border-decay\/20{border-color:#ef444433!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)!important}}.\!border-decay\/30{border-color:#ef44444d!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/30{border-color:color-mix(in oklab,var(--color-decay) 30%,transparent)!important}}.\!border-decay\/40{border-color:#ef444466!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/40{border-color:color-mix(in oklab,var(--color-decay) 40%,transparent)!important}}.\!border-dream\/20{border-color:#a855f733!important}@supports (color:color-mix(in lab,red,red)){.\!border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)!important}}.\!border-synapse\/15{border-color:#6366f126!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)!important}}.\!border-synapse\/20{border-color:#6366f133!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)!important}}.\!border-synapse\/25{border-color:#6366f140!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/25{border-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)!important}}.\!border-synapse\/30{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.\!border-synapse\/40{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.border-\[\#A33FFF\]\/40{border-color:#a33fff66}.border-decay\/20{border-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.border-dream-glow\/40{border-color:#c084fc66}@supports (color:color-mix(in lab,red,red)){.border-dream-glow\/40{border-color:color-mix(in oklab,var(--color-dream-glow) 40%,transparent)}}.border-dream\/10{border-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.border-dream\/10{border-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.border-dream\/20{border-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.border-dream\/30{border-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.border-dream\/30{border-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.border-dream\/40{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.border-dream\/40{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.border-dream\/50{border-color:#a855f780}@supports (color:color-mix(in lab,red,red)){.border-dream\/50{border-color:color-mix(in oklab,var(--color-dream) 50%,transparent)}}.border-recall\/30{border-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.border-recall\/30{border-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.border-recall\/40{border-color:#10b98166}@supports (color:color-mix(in lab,red,red)){.border-recall\/40{border-color:color-mix(in oklab,var(--color-recall) 40%,transparent)}}.border-subtle\/15{border-color:#2a2a5e26}@supports (color:color-mix(in lab,red,red)){.border-subtle\/15{border-color:color-mix(in oklab,var(--color-subtle) 15%,transparent)}}.border-subtle\/20{border-color:#2a2a5e33}@supports (color:color-mix(in lab,red,red)){.border-subtle\/20{border-color:color-mix(in oklab,var(--color-subtle) 20%,transparent)}}.border-subtle\/30{border-color:#2a2a5e4d}@supports (color:color-mix(in lab,red,red)){.border-subtle\/30{border-color:color-mix(in oklab,var(--color-subtle) 30%,transparent)}}.border-synapse{border-color:var(--color-synapse)}.border-synapse\/5{border-color:#6366f10d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/5{border-color:color-mix(in oklab,var(--color-synapse) 5%,transparent)}}.border-synapse\/10{border-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.border-synapse\/10{border-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.border-synapse\/15{border-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.border-synapse\/20{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.border-synapse\/30{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.border-synapse\/40{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.border-transparent{border-color:#0000}.border-warning\/30{border-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.border-warning\/30{border-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.border-warning\/40{border-color:#f59e0b66}@supports (color:color-mix(in lab,red,red)){.border-warning\/40{border-color:color-mix(in oklab,var(--color-warning) 40%,transparent)}}.border-warning\/50{border-color:#f59e0b80}@supports (color:color-mix(in lab,red,red)){.border-warning\/50{border-color:color-mix(in oklab,var(--color-warning) 50%,transparent)}}.border-white\/5{border-color:#ffffff0d}@supports (color:color-mix(in lab,red,red)){.border-white\/5{border-color:color-mix(in oklab,var(--color-white) 5%,transparent)}}.border-t-dream{border-top-color:var(--color-dream)}.border-t-synapse{border-top-color:var(--color-synapse)}.border-t-warning{border-top-color:var(--color-warning)}.bg-\[\#A33FFF\]{background-color:#a33fff}.bg-\[\#A33FFF\]\/10{background-color:#a33fff1a}.bg-amber-400{background-color:var(--color-amber-400)}.bg-black\/40{background-color:#0006}@supports (color:color-mix(in lab,red,red)){.bg-black\/40{background-color:color-mix(in oklab,var(--color-black) 40%,transparent)}}.bg-decay{background-color:var(--color-decay)}.bg-decay\/10{background-color:#ef44441a}@supports (color:color-mix(in lab,red,red)){.bg-decay\/10{background-color:color-mix(in oklab,var(--color-decay) 10%,transparent)}}.bg-decay\/20{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.bg-decay\/20{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.bg-decay\/\[0\.05\]{background-color:#ef44440d}@supports (color:color-mix(in lab,red,red)){.bg-decay\/\[0\.05\]{background-color:color-mix(in oklab,var(--color-decay) 5%,transparent)}}.bg-deep{background-color:var(--color-deep)}.bg-deep\/40{background-color:#10102a66}@supports (color:color-mix(in lab,red,red)){.bg-deep\/40{background-color:color-mix(in oklab,var(--color-deep) 40%,transparent)}}.bg-deep\/60{background-color:#10102a99}@supports (color:color-mix(in lab,red,red)){.bg-deep\/60{background-color:color-mix(in oklab,var(--color-deep) 60%,transparent)}}.bg-dream{background-color:var(--color-dream)}.bg-dream\/5{background-color:#a855f70d}@supports (color:color-mix(in lab,red,red)){.bg-dream\/5{background-color:color-mix(in oklab,var(--color-dream) 5%,transparent)}}.bg-dream\/10{background-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.bg-dream\/10{background-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.bg-dream\/15{background-color:#a855f726}@supports (color:color-mix(in lab,red,red)){.bg-dream\/15{background-color:color-mix(in oklab,var(--color-dream) 15%,transparent)}}.bg-dream\/20{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.bg-dream\/20{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.bg-muted{background-color:var(--color-muted)}.bg-node-pattern{background-color:var(--color-node-pattern)}.bg-purple-500\/20{background-color:#ac4bff33}@supports (color:color-mix(in lab,red,red)){.bg-purple-500\/20{background-color:color-mix(in oklab,var(--color-purple-500) 20%,transparent)}}.bg-recall{background-color:var(--color-recall)}.bg-recall\/10{background-color:#10b9811a}@supports (color:color-mix(in lab,red,red)){.bg-recall\/10{background-color:color-mix(in oklab,var(--color-recall) 10%,transparent)}}.bg-recall\/15{background-color:#10b98126}@supports (color:color-mix(in lab,red,red)){.bg-recall\/15{background-color:color-mix(in oklab,var(--color-recall) 15%,transparent)}}.bg-recall\/20{background-color:#10b98133}@supports (color:color-mix(in lab,red,red)){.bg-recall\/20{background-color:color-mix(in oklab,var(--color-recall) 20%,transparent)}}.bg-synapse{background-color:var(--color-synapse)}.bg-synapse-glow{background-color:var(--color-synapse-glow)}.bg-synapse\/10{background-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/10{background-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.bg-synapse\/15{background-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/15{background-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.bg-synapse\/20{background-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/20{background-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.bg-synapse\/25{background-color:#6366f140}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/25{background-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)}}.bg-synapse\/70{background-color:#6366f1b3}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/70{background-color:color-mix(in oklab,var(--color-synapse) 70%,transparent)}}.bg-transparent{background-color:#0000}.bg-void{background-color:var(--color-void)}.bg-void\/60{background-color:#05051099}@supports (color:color-mix(in lab,red,red)){.bg-void\/60{background-color:color-mix(in oklab,var(--color-void) 60%,transparent)}}.bg-warning{background-color:var(--color-warning)}.bg-warning\/5{background-color:#f59e0b0d}@supports (color:color-mix(in lab,red,red)){.bg-warning\/5{background-color:color-mix(in oklab,var(--color-warning) 5%,transparent)}}.bg-warning\/20{background-color:#f59e0b33}@supports (color:color-mix(in lab,red,red)){.bg-warning\/20{background-color:color-mix(in oklab,var(--color-warning) 20%,transparent)}}.bg-white\/\[0\.02\]{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.02\]{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.bg-white\/\[0\.03\]{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.03\]{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.bg-white\/\[0\.04\]{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.04\]{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.bg-white\/\[0\.06\]{background-color:#ffffff0f}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.06\]{background-color:color-mix(in oklab,var(--color-white) 6%,transparent)}}.bg-gradient-to-br{--tw-gradient-position:to bottom right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.from-dream{--tw-gradient-from:var(--color-dream);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.to-synapse{--tw-gradient-to:var(--color-synapse);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.p-0{padding:calc(var(--spacing) * 0)}.p-0\.5{padding:calc(var(--spacing) * .5)}.p-1{padding:calc(var(--spacing) * 1)}.p-2{padding:calc(var(--spacing) * 2)}.p-2\.5{padding:calc(var(--spacing) * 2.5)}.p-3{padding:calc(var(--spacing) * 3)}.p-4{padding:calc(var(--spacing) * 4)}.p-5{padding:calc(var(--spacing) * 5)}.p-6{padding:calc(var(--spacing) * 6)}.p-10{padding:calc(var(--spacing) * 10)}.p-12{padding:calc(var(--spacing) * 12)}.px-1{padding-inline:calc(var(--spacing) * 1)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-2\.5{padding-inline:calc(var(--spacing) * 2.5)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.px-5{padding-inline:calc(var(--spacing) * 5)}.px-6{padding-inline:calc(var(--spacing) * 6)}.px-8{padding-inline:calc(var(--spacing) * 8)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1{padding-block:calc(var(--spacing) * 1)}.py-1\.5{padding-block:calc(var(--spacing) * 1.5)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-3{padding-block:calc(var(--spacing) * 3)}.py-4{padding-block:calc(var(--spacing) * 4)}.py-5{padding-block:calc(var(--spacing) * 5)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.py-10{padding-block:calc(var(--spacing) * 10)}.py-12{padding-block:calc(var(--spacing) * 12)}.py-20{padding-block:calc(var(--spacing) * 20)}.pt-1{padding-top:calc(var(--spacing) * 1)}.pt-2{padding-top:calc(var(--spacing) * 2)}.pt-3{padding-top:calc(var(--spacing) * 3)}.pt-4{padding-top:calc(var(--spacing) * 4)}.pt-6{padding-top:calc(var(--spacing) * 6)}.pt-8{padding-top:calc(var(--spacing) * 8)}.pt-\[10vh\]{padding-top:10vh}.pr-1{padding-right:calc(var(--spacing) * 1)}.pr-2{padding-right:calc(var(--spacing) * 2)}.pb-2{padding-bottom:calc(var(--spacing) * 2)}.pb-16{padding-bottom:calc(var(--spacing) * 16)}.pl-6{padding-left:calc(var(--spacing) * 6)}.pl-14{padding-left:calc(var(--spacing) * 14)}.text-center{text-align:center}.text-left{text-align:left}.text-right{text-align:right}.align-bottom{vertical-align:bottom}.align-top{vertical-align:top}.font-mono{font-family:var(--font-mono)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-3xl{font-size:var(--text-3xl);line-height:var(--tw-leading,var(--text-3xl--line-height))}.text-4xl{font-size:var(--text-4xl);line-height:var(--tw-leading,var(--text-4xl--line-height))}.text-5xl{font-size:var(--text-5xl);line-height:var(--tw-leading,var(--text-5xl--line-height))}.text-6xl{font-size:var(--text-6xl);line-height:var(--tw-leading,var(--text-6xl--line-height))}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[8px\]{font-size:8px}.text-\[9px\]{font-size:9px}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.leading-none{--tw-leading:1;line-height:1}.leading-relaxed{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.font-bold{--tw-font-weight:var(--font-weight-bold);font-weight:var(--font-weight-bold)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-\[0\.12em\]{--tw-tracking:.12em;letter-spacing:.12em}.tracking-\[0\.15em\]{--tw-tracking:.15em;letter-spacing:.15em}.tracking-\[0\.18em\]{--tw-tracking:.18em;letter-spacing:.18em}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.tracking-wide{--tw-tracking:var(--tracking-wide);letter-spacing:var(--tracking-wide)}.tracking-wider{--tw-tracking:var(--tracking-wider);letter-spacing:var(--tracking-wider)}.tracking-widest{--tw-tracking:var(--tracking-widest);letter-spacing:var(--tracking-widest)}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.text-\[\#E4C8FF\]{color:#e4c8ff}.text-amber-400{color:var(--color-amber-400)}.text-bright{color:var(--color-bright)}.text-decay{color:var(--color-decay)}.text-decay\/60{color:#ef444499}@supports (color:color-mix(in lab,red,red)){.text-decay\/60{color:color-mix(in oklab,var(--color-decay) 60%,transparent)}}.text-dim{color:var(--color-dim)}.text-dream{color:var(--color-dream)}.text-dream-glow{color:var(--color-dream-glow)}.text-dream\/40{color:#a855f766}@supports (color:color-mix(in lab,red,red)){.text-dream\/40{color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.text-dream\/80{color:#a855f7cc}@supports (color:color-mix(in lab,red,red)){.text-dream\/80{color:color-mix(in oklab,var(--color-dream) 80%,transparent)}}.text-memory{color:var(--color-memory)}.text-muted{color:var(--color-muted)}.text-muted\/50{color:#4a4a7a80}@supports (color:color-mix(in lab,red,red)){.text-muted\/50{color:color-mix(in oklab,var(--color-muted) 50%,transparent)}}.text-muted\/60{color:#4a4a7a99}@supports (color:color-mix(in lab,red,red)){.text-muted\/60{color:color-mix(in oklab,var(--color-muted) 60%,transparent)}}.text-node-pattern{color:var(--color-node-pattern)}.text-purple-400{color:var(--color-purple-400)}.text-recall{color:var(--color-recall)}.text-subtle{color:var(--color-subtle)}.text-synapse{color:var(--color-synapse)}.text-synapse-glow{color:var(--color-synapse-glow)}.text-text{color:var(--color-text)}.text-text\/80{color:#e0e0ffcc}@supports (color:color-mix(in lab,red,red)){.text-text\/80{color:color-mix(in oklab,var(--color-text) 80%,transparent)}}.text-warning{color:var(--color-warning)}.capitalize{text-transform:capitalize}.uppercase{text-transform:uppercase}.italic{font-style:italic}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.underline-offset-4{text-underline-offset:4px}.accent-synapse{accent-color:var(--color-synapse)}.accent-synapse-glow{accent-color:var(--color-synapse-glow)}.opacity-20{opacity:.2}.opacity-30{opacity:.3}.opacity-35{opacity:.35}.opacity-40{opacity:.4}.opacity-60{opacity:.6}.opacity-75{opacity:.75}.opacity-100{opacity:1}.shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow\!{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a)!important;box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)!important}.shadow-2xl{--tw-shadow:0 25px 50px -12px var(--tw-shadow-color,#00000040);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_10px_rgba\(239\,68\,68\,0\.7\)\]{--tw-shadow:0 0 10px var(--tw-shadow-color,#ef4444b3);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f126);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.18\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f12e);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(163\,63\,255\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#a33fff26);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(99\,102\,241\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#6366f14d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(168\,85\,247\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#a855f74d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a), 0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring,.ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-2{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-synapse\/10{--tw-shadow-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/10{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 10%, transparent) var(--tw-shadow-alpha), transparent)}}.shadow-synapse\/20{--tw-shadow-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/20{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 20%, transparent) var(--tw-shadow-alpha), transparent)}}.ring-dream-glow{--tw-ring-color:var(--color-dream-glow)}.ring-dream\/60{--tw-ring-color:#a855f799}@supports (color:color-mix(in lab,red,red)){.ring-dream\/60{--tw-ring-color:color-mix(in oklab, var(--color-dream) 60%, transparent)}}.ring-recall\/30{--tw-ring-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.ring-recall\/30{--tw-ring-color:color-mix(in oklab, var(--color-recall) 30%, transparent)}}.ring-synapse\/60{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.ring-synapse\/60{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.blur{--tw-blur:blur(8px);filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.backdrop-blur-md{--tw-backdrop-blur:blur(var(--blur-md));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-blur-sm{--tw-backdrop-blur:blur(var(--blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-filter{-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-200{--tw-duration:.2s;transition-duration:.2s}.duration-300{--tw-duration:.3s;transition-duration:.3s}.duration-500{--tw-duration:.5s;transition-duration:.5s}.duration-700{--tw-duration:.7s;transition-duration:.7s}.ease-in-out{--tw-ease:var(--ease-in-out);transition-timing-function:var(--ease-in-out)}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}.select-none{-webkit-user-select:none;user-select:none}.placeholder\:text-muted::placeholder{color:var(--color-muted)}@media(hover:hover){.hover\:z-10:hover{z-index:10}.hover\:scale-110:hover{--tw-scale-x:110%;--tw-scale-y:110%;--tw-scale-z:110%;scale:var(--tw-scale-x) var(--tw-scale-y)}.hover\:scale-\[1\.03\]:hover{scale:1.03}.hover\:\!border-synapse\/30:hover{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.hover\:\!border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.hover\:border-synapse\/20:hover{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/20:hover{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.hover\:border-synapse\/30:hover{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:border-synapse\/50:hover{border-color:#6366f180}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/50:hover{border-color:color-mix(in oklab,var(--color-synapse) 50%,transparent)}}.hover\:bg-decay\/20:hover{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/20:hover{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.hover\:bg-decay\/30:hover{background-color:#ef44444d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/30:hover{background-color:color-mix(in oklab,var(--color-decay) 30%,transparent)}}.hover\:bg-dream\/20:hover{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/20:hover{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.hover\:bg-dream\/30:hover{background-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/30:hover{background-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.hover\:bg-purple-500\/30:hover{background-color:#ac4bff4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-purple-500\/30:hover{background-color:color-mix(in oklab,var(--color-purple-500) 30%,transparent)}}.hover\:bg-recall\/30:hover{background-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-recall\/30:hover{background-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.hover\:bg-synapse\/30:hover{background-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-synapse\/30:hover{background-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:bg-warning\/30:hover{background-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-warning\/30:hover{background-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.hover\:bg-white\/\[0\.02\]:hover{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.02\]:hover{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.hover\:bg-white\/\[0\.03\]:hover{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.03\]:hover{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.hover\:bg-white\/\[0\.04\]:hover{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.04\]:hover{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.hover\:bg-white\/\[0\.08\]:hover{background-color:#ffffff14}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.08\]:hover{background-color:color-mix(in oklab,var(--color-white) 8%,transparent)}}.hover\:text-bright:hover{color:var(--color-bright)}.hover\:text-dim:hover{color:var(--color-dim)}.hover\:text-synapse-glow:hover{color:var(--color-synapse-glow)}.hover\:text-text:hover{color:var(--color-text)}.hover\:underline:hover{text-decoration-line:underline}}.focus\:\!border-synapse\/40:focus{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.focus\:\!border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.focus\:border-dream\/40:focus{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.focus\:border-dream\/40:focus{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.focus\:border-synapse\/40:focus{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.focus\:border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.focus\:ring-1:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-synapse-glow:focus{--tw-ring-color:var(--color-synapse-glow)}.focus\:ring-synapse\/20:focus{--tw-ring-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.focus\:ring-synapse\/20:focus{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 20%, transparent)}}.focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:#c084fc99}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-dream-glow) 60%, transparent)}}.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:#10b98199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-recall) 60%, transparent)}}.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-40:disabled{opacity:.4}.disabled\:opacity-50:disabled{opacity:.5}@media(min-width:40rem){.sm\:block{display:block}.sm\:inline-flex{display:inline-flex}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}}@media(min-width:48rem){.md\:block{display:block}.md\:flex{display:flex}.md\:hidden{display:none}.md\:inline-flex{display:inline-flex}.md\:min-w-\[340px\]{min-width:340px}.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.md\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.md\:grid-cols-5{grid-template-columns:repeat(5,minmax(0,1fr))}.md\:grid-cols-\[1fr_auto\]{grid-template-columns:1fr auto}.md\:grid-cols-\[280px_1fr\]{grid-template-columns:280px 1fr}.md\:flex-row{flex-direction:row}.md\:pt-\[15vh\]{padding-top:15vh}.md\:pb-0{padding-bottom:calc(var(--spacing) * 0)}}@media(min-width:64rem){.lg\:block{display:block}.lg\:w-56{width:calc(var(--spacing) * 56)}.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.lg\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.lg\:grid-cols-\[1fr_280px\]{grid-template-columns:1fr 280px}.lg\:grid-cols-\[1fr_340px\]{grid-template-columns:1fr 340px}.lg\:grid-cols-\[1fr_360px\]{grid-template-columns:1fr 360px}.lg\:grid-cols-\[minmax\(0\,1fr\)_340px\]{grid-template-columns:minmax(0,1fr) 340px}}.\[\&\:\:-webkit-slider-thumb\]\:h-3::-webkit-slider-thumb{height:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:w-3::-webkit-slider-thumb{width:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:appearance-none::-webkit-slider-thumb{-webkit-appearance:none;-moz-appearance:none;appearance:none}.\[\&\:\:-webkit-slider-thumb\]\:rounded-full::-webkit-slider-thumb{border-radius:3.40282e38px}.\[\&\:\:-webkit-slider-thumb\]\:bg-synapse-glow::-webkit-slider-thumb{background-color:var(--color-synapse-glow)}.\[\&\:\:-webkit-slider-thumb\]\:shadow-\[0_0_8px_rgba\(129\,140\,248\,0\.4\)\]::-webkit-slider-thumb{--tw-shadow:0 0 8px var(--tw-shadow-color,#818cf866);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}}html{background:var(--color-void);color:var(--color-text);font-family:var(--font-mono)}body{min-height:100vh;margin:0;overflow:hidden}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:var(--color-subtle);border-radius:3px}::-webkit-scrollbar-thumb:hover{background:var(--color-muted)}.glass{-webkit-backdrop-filter:blur(20px)saturate(180%);background:#16163873;border:1px solid #6366f114;box-shadow:inset 0 1px #ffffff08,0 4px 24px #0000004d}.glass-subtle{-webkit-backdrop-filter:blur(12px)saturate(150%);background:#10102a66;border:1px solid #6366f10f;box-shadow:inset 0 1px #ffffff05,0 2px 12px #0003}.glass-sidebar{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1a99;border-right:1px solid #6366f11a;box-shadow:inset -1px 0 #ffffff05,4px 0 24px #0000004d}.glass-panel{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1acc;border:1px solid #6366f11a;box-shadow:inset 0 1px #ffffff08,0 8px 32px #0006}.glow-synapse{box-shadow:0 0 20px #6366f14d,0 0 60px #6366f11a}.glow-dream{box-shadow:0 0 20px #a855f74d,0 0 60px #a855f71a}.glow-memory{box-shadow:0 0 20px #3b82f64d,0 0 60px #3b82f61a}@keyframes pulse-glow{0%,to{opacity:1}50%{opacity:.5}}.animate-pulse-glow{animation:2s ease-in-out infinite pulse-glow}@keyframes orb-float-1{0%,to{transform:translate(0)scale(1)}25%{transform:translate(60px,-40px)scale(1.1)}50%{transform:translate(-30px,-80px)scale(.95)}75%{transform:translate(-60px,-20px)scale(1.05)}}@keyframes orb-float-2{0%,to{transform:translate(0)scale(1)}25%{transform:translate(-50px,30px)scale(1.08)}50%{transform:translate(40px,60px)scale(.92)}75%{transform:translate(20px,-40px)scale(1.03)}}@keyframes orb-float-3{0%,to{transform:translate(0)scale(1)}25%{transform:translate(30px,50px)scale(1.05)}50%{transform:translate(-60px,20px)scale(.98)}75%{transform:translate(40px,-30px)scale(1.1)}}.ambient-orb{filter:blur(80px);pointer-events:none;z-index:0;opacity:.35;border-radius:50%;position:fixed}.ambient-orb-1{background:radial-gradient(circle,#a855f766,#0000 70%);width:400px;height:400px;animation:20s ease-in-out infinite orb-float-1;top:-10%;right:-5%}.ambient-orb-2{background:radial-gradient(circle,#6366f159,#0000 70%);width:350px;height:350px;animation:25s ease-in-out infinite orb-float-2;bottom:-15%;left:-5%}.ambient-orb-3{background:radial-gradient(circle,#f59e0b33,#0000 70%);width:300px;height:300px;animation:22s ease-in-out infinite orb-float-3;top:40%;left:40%}.nav-active-border{position:relative}.nav-active-border:before{content:"";background:linear-gradient(180deg,var(--color-synapse),var(--color-dream),var(--color-synapse));background-size:100% 200%;border-radius:1px;width:2px;animation:3s ease-in-out infinite gradient-shift;position:absolute;top:4px;bottom:4px;left:0}@keyframes gradient-shift{0%,to{background-position:0 0}50%{background-position:0 100%}}@keyframes float{0%,to{transform:translateY(0)translate(0)}25%{transform:translateY(-10px)translate(5px)}50%{transform:translateY(-5px)translate(-5px)}75%{transform:translateY(-15px)translate(3px)}}.retention-critical{color:var(--color-decay)}.retention-low{color:var(--color-warning)}.retention-good{color:var(--color-recall)}.retention-strong{color:var(--color-synapse)}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@keyframes spin{to{transform:rotate(360deg)}}@keyframes ping{75%,to{opacity:0;transform:scale(2)}}@keyframes pulse{50%{opacity:.5}}.toast-layer.svelte-pry2ep{position:fixed;z-index:60;pointer-events:none;display:flex;flex-direction:column;gap:.5rem;right:1.25rem;bottom:1.25rem;max-width:22rem;width:calc(100vw - 2.5rem)}@media(max-width:768px){.toast-layer.svelte-pry2ep{right:.75rem;left:.75rem;bottom:auto;top:5.25rem;max-width:none;width:auto;align-items:stretch}}.toast-item.svelte-pry2ep{pointer-events:auto;position:relative;display:flex;gap:.75rem;align-items:stretch;text-align:left;font:inherit;color:inherit;background:#0c0e16b8;backdrop-filter:blur(14px) saturate(160%);-webkit-backdrop-filter:blur(14px) saturate(160%);border:1px solid rgba(255,255,255,.06);border-radius:.75rem;padding:.75rem .9rem .75rem .5rem;overflow:hidden;box-shadow:0 10px 40px -12px #000c,0 0 22px -6px var(--toast-color);cursor:pointer;animation:svelte-pry2ep-toast-in .32s cubic-bezier(.16,1,.3,1);transform-origin:right center;transition:transform .15s ease,box-shadow .15s ease}.toast-item.svelte-pry2ep:hover{transform:translateY(-1px) scale(1.015);box-shadow:0 14px 48px -12px #000000d9,0 0 32px -4px var(--toast-color)}.toast-item.svelte-pry2ep:focus-visible{outline:1px solid var(--toast-color);outline-offset:2px}.toast-accent.svelte-pry2ep{width:3px;border-radius:2px;background:var(--toast-color);box-shadow:0 0 10px var(--toast-color);flex-shrink:0}.toast-body.svelte-pry2ep{display:flex;flex-direction:column;gap:.15rem;flex:1;min-width:0}.toast-head.svelte-pry2ep{display:flex;align-items:center;gap:.5rem}.toast-icon.svelte-pry2ep{color:var(--toast-color);font-size:.95rem;text-shadow:0 0 8px var(--toast-color);line-height:1;width:1rem;display:inline-flex;justify-content:center}.toast-title.svelte-pry2ep{color:#f5f5fa;font-size:.82rem;font-weight:600;letter-spacing:.01em}.toast-sub.svelte-pry2ep{color:#b0b6c4;font-size:.74rem;line-height:1.35;padding-left:1.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.toast-progress.svelte-pry2ep{position:absolute;left:0;bottom:0;height:2px;width:100%;background:#ffffff0a}.toast-progress-fill.svelte-pry2ep{height:100%;background:var(--toast-color);opacity:.55;transform-origin:left center;animation:svelte-pry2ep-toast-progress var(--toast-dwell) linear forwards}.toast-item.svelte-pry2ep:hover .toast-progress-fill:where(.svelte-pry2ep),.toast-item.svelte-pry2ep:focus-visible .toast-progress-fill:where(.svelte-pry2ep){animation-play-state:paused}@keyframes svelte-pry2ep-toast-in{0%{opacity:0;transform:translate(24px) scale(.98)}to{opacity:1;transform:translate(0) scale(1)}}@media(max-width:768px){.toast-item.svelte-pry2ep{transform-origin:top center;animation:svelte-pry2ep-toast-in-mobile .3s cubic-bezier(.16,1,.3,1)}}@keyframes svelte-pry2ep-toast-in-mobile{0%{opacity:0;transform:translateY(-12px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}@keyframes svelte-pry2ep-toast-progress{0%{transform:scaleX(1)}to{transform:scaleX(0)}}@media(prefers-reduced-motion:reduce){.toast-item.svelte-pry2ep{animation:none}.toast-progress-fill.svelte-pry2ep{animation:none;transform:scaleX(.5)}}.strip-item.svelte-1kk3799{display:inline-flex;align-items:center;gap:.4rem;padding:0 .75rem;white-space:nowrap;flex-shrink:0}.strip-divider.svelte-1kk3799{width:1px;height:14px;background:#6366f11f;flex-shrink:0}.ambient-strip.ambient-flash.svelte-1kk3799{background:linear-gradient(90deg,#ef444414,#ef444400 70%),#0006;border-bottom-color:#ef444459;transition:background .3s ease,border-color .3s ease}@keyframes svelte-1kk3799-ping-slow{0%{transform:scale(1);opacity:.8}80%,to{transform:scale(2);opacity:0}}.animate-ping-slow{animation:svelte-1kk3799-ping-slow 2.2s cubic-bezier(0,0,.2,1) infinite}@media(prefers-reduced-motion:reduce){.ambient-strip.svelte-1kk3799 .animate-ping,.ambient-strip.svelte-1kk3799 .animate-ping-slow,.ambient-strip.svelte-1kk3799 .animate-pulse{animation:none!important}}.verdict-bar.svelte-1j425e6{border-bottom:1px solid rgba(255,255,255,.06);background:#080912b8;backdrop-filter:blur(18px) saturate(160%);-webkit-backdrop-filter:blur(18px) saturate(160%);box-shadow:0 6px 24px #0000002e}.verdict-summary.svelte-1j425e6{width:100%;min-height:2.75rem;display:grid;grid-template-columns:auto auto minmax(0,1fr) auto;align-items:center;gap:.75rem;padding:.55rem 1rem;color:var(--color-text);text-align:left;font:inherit}.sr-only.svelte-1j425e6{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.label.svelte-1j425e6,.field-label.svelte-1j425e6,.appeal-row.svelte-1j425e6>span:where(.svelte-1j425e6){color:var(--color-dim);font-size:.68rem;text-transform:uppercase;letter-spacing:0}.levels.svelte-1j425e6{display:flex;align-items:center;gap:.25rem}.levels.svelte-1j425e6 span:where(.svelte-1j425e6){border:1px solid rgba(255,255,255,.08);border-radius:.35rem;padding:.18rem .38rem;color:var(--color-muted);font-size:.64rem;line-height:1}.levels.svelte-1j425e6 span.active:where(.svelte-1j425e6){color:var(--color-bright);border-color:var(--verdict-color);background:color-mix(in srgb,var(--verdict-color) 18%,transparent);box-shadow:0 0 14px color-mix(in srgb,var(--verdict-color) 28%,transparent)}.summary-text.svelte-1j425e6{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.78rem;color:var(--color-dim)}.when.svelte-1j425e6{color:var(--color-muted);font-size:.68rem}.receipt.svelte-1j425e6{margin:0 1rem .75rem;border:1px solid rgba(255,255,255,.08);border-radius:.5rem;background:#0a0a1ac7;padding:.85rem}.receipt-grid.svelte-1j425e6{display:grid;grid-template-columns:minmax(0,1.4fr) minmax(10rem,.8fr) minmax(0,1.1fr) minmax(0,1.1fr);gap:.85rem}.receipt.svelte-1j425e6 p:where(.svelte-1j425e6),.receipt.svelte-1j425e6 li:where(.svelte-1j425e6){margin:.25rem 0 0;color:var(--color-text);font-size:.76rem;line-height:1.45;overflow-wrap:anywhere}.receipt.svelte-1j425e6 ul:where(.svelte-1j425e6){margin:.25rem 0 0;padding-left:1rem}.appeal-row.svelte-1j425e6{display:flex;align-items:center;gap:.4rem;margin-top:.85rem;flex-wrap:wrap}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6),.appeal-row.svelte-1j425e6 p:where(.svelte-1j425e6){border:1px solid rgba(255,255,255,.1);border-radius:.4rem;padding:.35rem .6rem;color:var(--color-text);background:#ffffff0a;font-size:.72rem;margin:0}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6):hover:not(:disabled),.verdict-summary.svelte-1j425e6:hover{background:#ffffff0d}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6):disabled{opacity:.55;cursor:wait}.tone-pass.svelte-1j425e6,.tone-note.svelte-1j425e6{--verdict-color: #10b981}.tone-caution.svelte-1j425e6{--verdict-color: #f59e0b}.tone-veto.svelte-1j425e6{--verdict-color: #ef4444}.tone-appealed.svelte-1j425e6{--verdict-color: #818cf8}@media(max-width:900px){.verdict-summary.svelte-1j425e6{grid-template-columns:auto minmax(0,1fr) auto}.levels.svelte-1j425e6{grid-column:1 / -1;order:4;overflow-x:auto;padding-bottom:.1rem}.receipt-grid.svelte-1j425e6{grid-template-columns:1fr}}.theme-toggle.svelte-1cmi4dh{width:30px;height:30px;display:inline-flex;align-items:center;justify-content:center;padding:0;border-radius:8px;background:#6366f10f;border:1px solid rgba(99,102,241,.14);color:var(--color-text);cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease,transform .12s ease;-webkit-tap-highlight-color:transparent}.theme-toggle.svelte-1cmi4dh:hover{background:#6366f124;border-color:#6366f14d;color:var(--color-bright)}.theme-toggle.svelte-1cmi4dh:active{transform:scale(.94)}.theme-toggle.svelte-1cmi4dh:focus-visible{outline:1px solid var(--color-synapse);outline-offset:2px}.icon-wrap.svelte-1cmi4dh{position:relative;width:18px;height:18px;display:inline-block}.icon.svelte-1cmi4dh{position:absolute;top:0;right:0;bottom:0;left:0;width:18px;height:18px;opacity:0;transform:scale(.7) rotate(-30deg);transition:opacity .2s ease,transform .2s cubic-bezier(.16,1,.3,1);pointer-events:none}.icon.active.svelte-1cmi4dh{opacity:1;transform:scale(1) rotate(0)}.theme-toggle[data-mode=dark].svelte-1cmi4dh{color:var(--color-synapse-glow, #818cf8)}.theme-toggle[data-mode=light].svelte-1cmi4dh{color:var(--color-warning, #f59e0b)}.theme-toggle[data-mode=auto].svelte-1cmi4dh{color:var(--color-dream-glow, #c084fc)}@media(prefers-reduced-motion:reduce){.theme-toggle.svelte-1cmi4dh,.icon.svelte-1cmi4dh{transition:none}}.safe-bottom.svelte-12qhfyh{padding-bottom:env(safe-area-inset-bottom,0px)}@keyframes svelte-12qhfyh-page-in{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}.animate-page-in.svelte-12qhfyh{animation:svelte-12qhfyh-page-in .2s ease-out} diff --git a/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css.br b/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css.br new file mode 100644 index 0000000000000000000000000000000000000000..47524118f56c0c1679dda8934fe36c436a5f46d1 GIT binary patch literal 10353 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

;Ec~Y*D!@u8*ko*?#!Q)l zO@}A*wuPp5$nGiFY~UGy`LP6>jy)%YO+e7kU(Hl!baR5xWacC;iA)#`6O#t<&O<&o zQzM_-dK1blbf%G9oj`LqM{<8V%atybq~i@DeCg(APMvXU$J^;75s@Wg&mW+1i(XrU z{nWWP_y^kLlr(1s%fQK$J>Dbcdk>r2^8(tUFMKmiqD__^fn#X24ZeSA)nn*72}e0~ z;LA%32y~4yG{;1T$aobWs8P(m`<>&_*qI@SHf*AY8^?Aez6`FMA2|Dv`1%f2!NWv1{BMrCWhSX^o`9#TWX>GRvk6*{x&y`ZE~d0|c# z(hIE6y5FYqbAv}qjTDj!$T&2)dg~kDJf=`w5pu@?Tv2f?BtW2JOo07AVEcL-J3FQ| z={snkm6vKxA-JbIGh=4RSk^=zcuKn$HgfT!iFQYm$Q|i1M0&R)YrU=kzD`I^3i(*# zoHI^=VSwW`fRi8LIMc!-)73S?jZ*?)VM&zqjS^%x(0GxjfGv&O9$@iQw`_H~q0}+W zNBAx`KIVyb;ZUg4Gmc&@g3XVv`vhjFPX7eaPbNjzPoizs7^Nb;XyT98J#eYpG9JrK zPgr1fZYT?);WmYb4`*qq`KcSTTU>BB4Zy=!rmlarVxC@)xINSDeUu#+6vKWJa}7V- z6C4jVtW7~vKZ(N)C40a+CudT>e{XSf^YOm<{P|s5>v)OqjHb^DW@AX-G(6|cIS~L9 zZa=a8P$axdune5LuO;qn<~|+91-rutuJ3gxv|B_}7oM_Q%U)2Q57Yf4DJFj{`TorD zT9R|znljl+j32fKv_weocAAaiSxZAnfEBpdc>D7Hxle-Cm&aaoq9eQIBgpy14Kson zS5Sq!bR)_8BFp1ye}Zsht#;{~m}Yd@K>R`%Uh(wGEySgIPQD}gRlPoRixNU$BRa!{&|E3}_zk!P4d!n-lEdr`!6*J| z-jLS>LH*UktGX;`qSt>~p-LAi(IPe>T%y0E2XDkE6z$=3fImV-SOg?x?wElOsA%;j z7^J|%co!02G?njh-(Sl{r8HtyiX}e|S-?L&ihfa0Um+Tx#~Y&HTf0ynX>ipoNu7KW zn_e(-89|Sg64}o|94uw%C?)@3`0;->L6>3!3BVR|p@+^*+%1uZ9Qe9!ZYxwnn=!)W zMXB0mtsB;j#PM-L8RiW1CI+|uIztsASpmzHAkH#yBU^n?#E;)>dEVo6=7rLn^C@x8DGp8@(Ww`vxcJt=vZFcQXxA+S=PBDu}5&_)T04jc*H8RK2rXyBdHutu-BJI43pqmCSK7g)Mb{|=#{I>lDsIXk#i zp)&|T0GFwCB_NJANoB)Dy=@~w_1?np0pA|c?r|8qBKUfEkZY$ohQm=boiB8{uILuS zEi4cE>)^YQtC@}0KB9Jy*FS;cZ*ml$BgzO8uKcviiZAtBQG!-0wyMK2BDCd7LNyYu zgWL>kuilW`rD^m&wo#GP$f%x#LfhfgwrcVs#-P`y4C2VrmL&;M{Nw%_sT1ZJ_=h_& z?zJ|?AorFTUer4^!DERxUx2`&Kk<HnRUPa@cr+sGEUOh##R?^E%NiNC^@{c+W5M>NU9cn$D&kFV`H0%VISsm&+ zA~+=weB3o-+-87(CCP4IHUl6VtiN{P;M(LEr>%5I<6=)X_BWDe&5+~yK=Nd5Z30UXT+M>IMnx zOJTGwK$S*va63cDVMX$-rG%)ZRlci&G)}AlYHwD-8n;&AI{#Jxm7}XbrN^sKwd?C( zMH(Q!Q|w7xR5GsDD{qC%JvoreBG0mNy4Yt$35^}C)e30G7UzWi7b3}%?bIsXi;^7d za{@ml@^}AuI;F(=6Q-*5PlxPp$#+2f3)yAF`rrSop#0_iu*y;-{cBcc4aOyp{*WEB z#drUMl>a@Cp=4TrhHqr}G09_K*bpl4M?pt8ZP0+9<}N!vte_bS9A}YzP1pN}xi_1C zwr1}9$(jeVz2BeB9rkqLM{S}9)Sv?m zfEsqNAyA{BO^ty1*pcuE)HzqSByS}uKYI)t1ly+d-JUg-P?FXUuJwZju!#T_hsA8( zU@HzPHt-g5&L!3rW^GsEL_(9-a%Z6>g289*%=P5B(w#D{M~sVNtH{7wch=y2OHI5I zt4DcdR!_<6QO26jr+iK4_-#&%sKf5@dG4J?~p+w9{8o!YZ&?67&*pWOJG((FN;3O!)$lIVn zW}G!C;MG|RL~{c%SPZM1hL_gzn2HFZSZFZY2+A3J&5Rew3nwk@crXpu{x|OZVavafn0P zF5be?ewAp?cueod_ykG)De|Le>$d6kE`_e)r@1>{Z)?3bIf)_8cpiq^$0n6CtettV zUDt|}LzcfUKKZM;w~Z=tPM}sx(Os*jxhwf_9Rrwb1Nf(IjN|->`T5f}d?L=Oq937q zVV~l%B>54T*1`Pgsp>Fc(}I%)e3C%S8Pt;ntLzPXsVJC_rGc_!KVcleI{R!61IFB^ zcteMk&ULZaCeX1cAPLtc`u1Fw*>SYEeR)VlkB-l%utpU+(007}+Zif1*2Ts-lQLeh zu63}Kem3gyS-9+GZAAf@{`+?tCtNdvU1fA(S%MP^rH(Dkl(k1(0x%@B0x`Q*<>aEzgzf4Vb7D0x zm|B1N5eEzQ|0KI}8s}5%&*Ye9Qyf9WYxwVnYE6IgIRe)_^t#s2|@io1{2F9ll7D z0yKd->6)d}b2>ecKn6Pzuv5pWqL1?;^E5y%3T62)lbteSR#JHr3RiJs`~0C0r&%qyYN=qW=j^34dc9o z@jq1j8b9(S5RNCu%_5*+$Zcz~r2q4RkvHLH{B^;(q?s1s08Q8K|h!t4T!Uhk!r=%R24tp#eH4US=A$UQKA zAdoN9Gr7P(qUs%`d)B6`QEpjPMLYqwDS6Xj?QKHRO<}+0s9b)LJB(`K zA~(@mM~}1L!Bi%FFblLl<^D#V4P>d?IQG!i-l|w~gptgROa){BNYPtkN};V7#R*wr zlR#Ivj}0f9j~hswQ?mXFwG*_Okb|N4Um6{9-Yh~VCxO-ph5>A>z~fKSq%n2cK#Z#mq$xZTeWc4vQY0&k=)LYY%^+hSIc)?p zv#v8m5GP${MQ&%u^!>695sam+6i6(N@n_Bz`pZ)8&k(9i2k^i40_-s%imS7;FG z5cZ99C~faD9lz0sxQ^#s*!m!yG-aJ~-u0MR-&@W^;NAq1H_iqI+RQh=yyb7AuQR9& znlNne6`<$e^}(e4I>QmBL%ZpE6)EO<78+o)kmFnf$mJN{fblsdFkk`^mq~FKHK!9( zU|(KObt^4oxWI_RSlIvv1oDxNULr>ZW+ckAQ?f1X=P%yV>FxQa3w|wZ{J73&i2MA5 z$EZ;3I4xiVy-X*QIe4gaSBUop!MXDOAh6HC!5}bAjkH$7P$hW`>JNbW3@R4_ie^QCwtMR|K45z! zx_&hgS0gzQ`^tQ$pco=n^EDEt+Z&Oh@KjNFca6eVMd9Byia-@b@bM_>G8b7U_G99nd{viXSvKFcJyHIw#~P!Cv;zC_u*wRGZTtmRUVCmcgT-A07o2{L$-&KYA7XDe8wmMHT${ zOT_&paYf8$bgmJGAJUwoeh9+A!2onn!(ki}@YriEN~#gQ*FpGR0}*x+p^TvED^Hx# zG=62(AnO;KYQa~i1x+ZAVfuu5T$pb}`4kfvF#*MxV`FheModI8k4DTR#mtSEImJ8~ zF;5iZnmy?kjQw0|<|^~Cgod`!5gAFy zM30LsS@Re7z zCTpDv3k9hUObZi7NB!uiLSy^XgJ#VWMT6UOa^STu_d3ooRKfl;-D=oC_>{!D-_T{n z|6o6teir*YIexuJzgt1zC^^u%&eSYA^e)d{84Z6SQk*{`rxpU7f! zWu0?cmK{2utz|{xN!~EY}M!&2wB{__=kIt3~<7DD1>QC7kn1(Q$s9 z)WnFlS$?=wziLKtCTuFPiW6Z9+BccTPJ?wQzy|{zzBTjt%QoJSzof~A{0xH|KP-M0 zn@oR(5&j;s3xm>~l@M%+U<-q-in|txTSO%$7P%ZKMNjvH>cJQ)p>YLA3&udeuFrWv zcm2^_GZ*%`;Gb16Ur!Oi{1X=saN$_2AESkW#@1nY02_JofcMUF^Q>O9Vr-f<=FXZI zCAJr$=|~t0K>zs&eYxJlZnjgnOQvpt8ZrY z4XlBgH88L~npqz^th6ct6suDkKyp6}H$kbfN3`beB+3 z?jP|k-=Ndq+z?fyZl`zkM@;JsfV0?}V z448mpOd1J&A_FGk7-*SkcL; z7qij3qlMmR`}|+bKL3vP`J?R%elh!kJK7hFw(plKgZC_fo4`7uc7JaHnvx3)hi!AG2|A_QW?vL3RUfX*&&M^6py|HUYITmJ zX>ux(LbZ#lvxFxIHeYqq1NgRt`kODvR)qH!;GF|#KbCAR&7Iin;A9m_C)An<=92n& zh1SQ0*F4aLey3=Zi zBo6Hgs}g{^bciSllmtEhjt9^~hR;8E&ZTj>g`Ya~eQEREE&JkoBT#IT7c-mH*~f|H zwYJL3TUR?#_-Y%1&An{!N7>-tVnd*|A&Ty0LomvQV3-Yf@>P+S*a6vlz z+&*2k&E7|Jy-!ou(bZS$8f-qIt3OItzfaddt?Nf}?zl`lAisucUFXh6bPY%88ftZA z*NrGL0lR->WG2u_?a`L8nX-Wp9H`YDnGbYQ2db;j3GB`qMgNgqV&jcdS0}ZvDWq)O z9%EPCPVL3i9a($nqz+Wq>-Da$R(E9H)kz(wu0HSbu1Hg=s;|=KfKspQRyiXL)JPrL zlL~tbRJ7Dg-;ph~R_x#*lGCrTZh-eejqfz5Q)sLm$bC%Xdkx+c8f%9+AJh0=LmP$0 z+TqN{G``mmrq)=Zwlu~&LMj-)E=-XW?EbKkNud?nV;JW%B}FAVP-{FgDYRmTY8>=y z9I7=Q+5OXs9jdXu3rLqyx^2vs{xh;ZKzc|k` zCsgKOrt-~I!VuZRG!NB^lT%;rA*V@&)szT!KWP+=Fit14*C=#w%ZY|>66^!pPF6g zBsK|VHkeP8Nq9}kVzYQ7N|s6Lz*#)kV4kLMF?B~2E|b)u>V_tDJ-v5FWFnK)f$FL= zPt`X!Zc=BRefi6o82BeI`S>__IPcFl<-jm9H# zpi%5c=BRef)qah}f%5^4Kj34}?Bhqhk5?b?@#6=4{HXMCV}43`k1d7an*!!SjfhEw z)pU^AqXZ*5$aA{h+S6nUoah$3$k zJ5*tHk>|5hY&hyEhq`?BE4*FpUfIKD!Mt9@eUswzk16htSKRMaJTNI9e@yXUyy8Kx z;*m-5?Z*_4#w#AF6qg@^T;&(d3z%hQv5mzR-EwV-Xyn_*lS8~C3-+Q;CE}slV%&W1 zk{)5j$1B;qfZ}D%?(j?bZe~}0^=9U@8zu~zOs#GpMmy2a&75U6QBrFzdYxz0kL|n* zs%j&D3U zMm?yAxueg&E_1Nk=Mj2m$LX#1ulaILm!l;Q_AoFfAqpP_?c z=zyUI>cTaNhM^;do)1Igl}D%dMv38ce3-vo;qYP7>77QWQpzjlt8!1Jltf*m0XPauCWEQ8x4cgE0#{F%wh58(Bm7Gr3JPv#bSC zd7}-f<>H&XCZQN^l1RgO)rhZnFimp*PhL^4D6$>u07oxS`w zM0(?mz&;e0F5X`rB41$pVyJNR>O1!0GM&kBJ$gN%xQ&m7EGV`8;u|G)*h3|IsA3Nl z>~kgiT*W?bu+vwkTa3KaHXxI>ASFl=jPFpJ=KW&xA#(G!;G*o8T$DpZ z7wC#rPU5dNE|b4z`NpQ7i;8%i(Rn;}?*_Za;?lj^qJcW)#O~k(v8wop5;gWF50=Q=xe$A!{aCkFJYk0RqOh^6B^Q)gZdg(%4sa>w=9^*06nKij^8B zEjg%^PY#vpbXHTp#i<6d6>1GqEK1jKx`FINXWEpqMjvI9rOjKKt=Ho9cJS!8?bIN;v6@@S-V(ocqqb63kCjXh)!uAbTGY~PR6%LW8m5`9pfol+ z_3m(@EPN}Gy1uCc1)T3IGHfPdonU(GN&(~Nu>_1y(3^Ib$Ut4`ZEY%{EcizOMY0T$ z%Mp8oepESXiRwv4s)V)_iKS`Ndh|LzB_)i%zwv9B>f3$mkn8M>FMFK4@(p&xe9Fyzqy!Ii=f19LJ3(Q;VTJ_!r-1>}6O=&x}@B_V6I1 zPNpq#PKR0TFiPbqt`6)_IYHR`{JVcYtLqyt{{P!AKjX;N#ksnsFT4<}3LR>n*Johh z{ECtl$6`M_KjSpS&-rc@KR)AKZ%vwvZn_V_#z!?em?NKZ#^ChH`x{9mD&US;MJ zSm`?6^VADmYNs2j4K<{v*w*+PGju-IQ1Yub)Qx<|wD7MNhGSEdon`w~rf8&3QD1Fm z)R&;a=2vZ}i#5Dv3(lLcXTOLt}>0v$t*jLa)GXTB1JzZUrC0h-gva+{3pR&p0qMSB21s$i9Wsz9Zqs!+AZs^G5csvth!rVLa0w+>{EUjE%5 z4S%$ASaBGV!-~V-bJ*W=*v&bNSI2+PIDgMLgE9{7;?N^Im-?rD0u03Y&iYH!_HnbR zd|B62badF4*ldyI^wmmE1$U>@qRg|eWZFG!H0>N{nzm0CO@*oTIC5Go9!{&rOsCAt z+?y(0&jxkA6u3F(aZ{L}=miSIq>;FEPmwBtf&Lq^f@Y@T*PT;;L+)%n z#oO{|U-A028!CR=p2G)%mBg7>C}RS;#OHVUd<~y3^Mzf$P{S9>e2-neM-AU2@X?ov zlOv8hFO{#kv!t*|e>%x%E>|n`28m2uK~l0Vn-2q@3;OOg2Czqf+XOs?60gZVOQG~W zFY1j+i-i=R->~&Z+%+6O?6KZn(7%(*jQ;m|@y&J}M!S3it2g)vxN{Yu{3YxP(tHow zb=vP?wTE;jMF) zH^uRRD`PbA^rY5ZY`Jd=>1_#3w%oce@}@Wj-$AaoMY@|Gfxv;D-H(!Oyg-EN3s^!c}D97EITBX;~kX;a(6 zcFJ+t|9SVz$=>ird&Bz==#56r*>+5C9jcH-M`db3BPV%oi)8$6w7S%Y#RZ(cl%r|x z7NWDAT@shVmYh=3%yokLpFQ`rydys+8#!86HD0d0bwk;Q;~liGk3Vc1=`vSK0Wr+% zH<}G-?_u=dIEQWv9BQnzo3GE>aeD?o7U_pJ6mF6t2BDkh1r)e~9*4$jupl##%|ZlT zSlB`elR4}2mNkcb@Un{xRme~*nH-WM-?A7uIXU1S-ve|#@Zz`&Um#~+R~o>sE3~&M zd8>jY8UyX}gbob~+q=-;B{`gMJrRlL!?9T8xKT|Xj8;-!BSv9g_E_w6~VTonZ@SEV~muEKy$#-Gtd1>=BSrBQZh5Mo*$fNH0*iOqejCET%qgi`OEWv zg)#F&tZEl&LLUI!pAW0&pP)Lh{e?2{!s{yiHJE*(U$vr5`Dcja_yj2r&D5IrWYw_< zVvS}!TlkwPt{W{ROB(kx$=QPzQARgp~I{sWN{8`|5bC3A+BDg;Bt=D06G2HNG zOka$RBbM{}gr$c^NdpIuShCaJ0Uoi``Mh=Ta;`sqH+Sdj?L7KboTI(&%Y*#vQ}>yU zrDpnUX}q{|m2KW>8!4{ebDWp`@(|~{1_Ly3_(d86w_1asH9&h2t^Guh1rdP*^N%@#BTibRHZS?njL4x zT|Md59FC-DK)==AJjF+n-b2;(TA$+akQB#S$QRCxP`~;-;6>uc8jGGbuGS`}NQxv9 zzF|w*#p}HaX0d!OF;}lFGG>0`my+9G&An~Z;ASK|?)jCxZ}a#-3hQ)E#pO9TNt#Jl z&_JG)2Tj*md`u45RgicX2|JixVM%-ItmL>&j!8+R2;^w9dMFGDQ~11w&z{1`^-&|-X3{-bx)WljS7nL! zF-vT`)n)28;+pGCL6fJEY>1~f#Or#=@pX3iAG3qHIBdI2nq?aj^2BNV z7R)-y*D0A+%Q@_#0DKERvni+*HsTq9Ch~ z!l$l+ekdu(J|qRhUIo1+A3fS`_<2chSMR9k4^dIPm!(iq_MzYQq1UUTPkk6TTs`=4 zogL#B8?P~YAvVhomnswBHN_a904-JoGArJuM^98NzWYvYg4!er{_!>Lsh{E5C)=_v0`UqO%`@(XN1uTxp1k;zy3dg- zl%^D3r${PSVzGmX)q^?=jcQa>G~x7B)L)^FlIts7J@wZI8?W||upxZu>M1~n4KV%G z)l(?D3HK3wo#h1c20ek1C-fSB!@aOISbgteeIH?s+-2FubU$Q`#B(3YYYwX$_Wmf2 zM_A(CUuKN`b^%Nozb(G|{<~#z+!L^+SZrfx=$Dv-unfP%>6u`L&FphfWyJ-V<*LUjUPlK8Ijpt`-MIQop+2tQR%z>V~A zH;w)wCC6R4xA9U|K*c-KXBo6eCiU(RLuiOXdVB5zG0=9k6$M{M8tz%?^8evX;x72% z9Q^v)8|nz@a@*lt&8u&3=i}4QBO>J2=H6f+yB&6L-G{R+s^TcmrQRAlyN#&Mf*;F! z@=Wc=?UJS4YF&f(t~S<-={GdM^^Ehq+%iUu&W!oTm8m!K+~^H?S5LbJ{KKui09j&> zPulI3eE#_c4!oISI9$5RX%y3~MP6pTYc(hf#)*p?a-@89$r!c~Il6Q0$q3dFd0cU2 z$_VCLbA9`|l@Xk`mxJb2EjMIPen-G?4xH{Xq3cd1^iLpNII3Z|(6s{Fb&|;6n7PW#jv`xap_b3{-JE zMtJGp#b6bSdiF@8qO*wnH`fC9MbQbzu%iyOll`P9_DE(@l0&g5%AAzzedSQ3cKq4! z8Wqu*>23OvdW@;3h-}$<_meK_FL)l~EC1rFu{^nUh#RfuOZ7@IE^b=&>Slzq-{!St z6-Q_36Zd62cwsmd|IVDKy|MCxtXl+4QHkKsm70N;VW&!qc)^uIc z^IDfH)3oAyvH50Do=nobbt4%$Pja+ozE@c5^9lx3EAlNN`NPbOrtWm+Pu)pf8eue< z;Jyi(@htXut8~jpeHV;1bNL#FbQ4oe)aNX5@<}~0Ow&fJjJe^YMy$bEZ@W}`OBbBb6+p-PfA%q;e65QR(lDllu-ie^DvFYXnd6Udi zy-C8Vc1iSgi4^^kPNG8ZXIPp-HFn5W3A)eMH-*=JuW&KF&cXJ~yU{&=ZTZKni^u?% z#=0zJ|3Apz=%RD7v@QLVlP$>$J13j-nry%>-n+w3QzF!kX8U;iOK_88+0kki(i`f_ zJUKNYbiaP}AD^C7hb6SFOd$8l9NraERC4WRlf}MCUU08%TY>8KZc(+lL9_K1d)KyY zv0_696<>XAaT2~AiD6H~6WtQQZ}4#g@r!TxpnE^Wc1V6Kp?T>~_#}7Z>WFAz;N7_T z@Nh*{heWKHyY;RmUn?dHQtK#`}-rkTP#(WjXk$2Elf;$De6E_U5+WlH*>P%-I z6y<8q#?buUOsQs+Rztn%4Opt@Uj#Hpv>tHgy*LTi}Hxx-?S1e=H-9 zvF6T`>uJYW^P9(5bLALI>dQv0{lOloO)JiaL!7_2&6D~O(r#~$7jIEP;JJ;Z`tSyh zVd+UCt9gv0Gdz|nlhzn7q{BMehtzFWH;r?llF9Atn0Aco_NclQ4*aZYHL<@PM@*e= z-WvLK3+&g^vH<^^sA@kx=7kz6jaMXXX*8W}6OwLhbr?O#k>XLRR?r_HiesxQ!helsJvb2>lZ&(&Fp z?dWf~rrYf|DL-TT?}jG@zer`-xI=;gM8On;(z@nooO&(54^tI~<+iSP>5OZ!CKxEo zYhM>LG`EVSOSsu{pB zxsb7TcmF@uIddM$y4YBk>dKd)vaPGwS%8%+|90^#@pLwqNCj52wQ1+{lO}&p zbqr~uD-qnutXjZ}6U?WPcy5TgWAPxYa+-~~XAvLYX`EUs&gpQan!|kR8*ODgtR4*5 zyfH>Z&$=>~vtBIKpG^p8W3g6e=x`jhDWPXPeV~SQJ6XHY?Pt}kHH%CwwQ4$|k-A>( z8rqW|=K?klfamrfsss1n7jt)~d*Dl`xEZgA;<$e(W|CiH?4AHKzQbM=ohF}#fDNRb z$yzn^!s540aA9lcUM1PFpNs8d=UgwO%=%f_(1x=xr;trQ8#@)*oqTx0E%Go9=;??W zdY9dfrLK!24j}{Y!nJ;|YzO@R4KhU2QZ7qyw2ECqg z&?~5|PkGUU)2i`L8K3MuxGF_=@f;>~PmKOnlyUyTZ?IHf3cWO3fM<$`bp|^F@Yz$) z!#Helq`5aKfn+y4U3Gy;RM`YtnhQk+frCDk|Ypsb; zzgRtcoLGFt+xF>-x17&7pECcL7U2{N)!aUod~GvT6NzH>MX2Yr()Y_IE@S(UZOHF8 zasKtEwoLO0_o=8m^-^g$7$BCP&zOpOUoR2szySj53zR@6yX0vyc%oBZ0;b9wCZ#q_ zCK!aoTf%GT3he#ce*3;}-xflSFAo$A6-3Op4zi#rHb1HvHzo+${<^KUKpK=r{69E7}l64aR literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css b/apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css deleted file mode 100644 index 73d4560..0000000 --- a/apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css +++ /dev/null @@ -1 +0,0 @@ -/*! tailwindcss v4.2.0 | MIT License | https://tailwindcss.com */@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--font-mono:"JetBrains Mono", "Fira Code", "SF Mono", monospace;--color-amber-400:oklch(82.8% .189 84.429);--color-purple-400:oklch(71.4% .203 305.504);--color-purple-500:oklch(62.7% .265 303.9);--color-black:#000;--color-white:#fff;--spacing:.25rem;--container-xs:20rem;--container-md:28rem;--container-lg:32rem;--container-xl:36rem;--container-2xl:42rem;--container-4xl:56rem;--container-5xl:64rem;--container-6xl:72rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height: 1.5 ;--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--text-3xl:1.875rem;--text-3xl--line-height: 1.2 ;--text-4xl:2.25rem;--text-4xl--line-height:calc(2.5 / 2.25);--text-5xl:3rem;--text-5xl--line-height:1;--text-6xl:3.75rem;--text-6xl--line-height:1;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--tracking-tight:-.025em;--tracking-wide:.025em;--tracking-wider:.05em;--tracking-widest:.1em;--leading-snug:1.375;--leading-relaxed:1.625;--radius-sm:.25rem;--radius-md:.375rem;--radius-lg:.5rem;--radius-xl:.75rem;--radius-2xl:1rem;--ease-out:cubic-bezier(0, 0, .2, 1);--ease-in-out:cubic-bezier(.4, 0, .2, 1);--animate-spin:spin 1s linear infinite;--animate-ping:ping 1s cubic-bezier(0, 0, .2, 1) infinite;--animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--blur-sm:8px;--blur-md:12px;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono);--color-void:#050510;--color-abyss:#0a0a1a;--color-deep:#10102a;--color-surface:#161638;--color-elevated:#1e1e4a;--color-subtle:#2a2a5e;--color-muted:#4a4a7a;--color-dim:#7a7aaa;--color-text:#e0e0ff;--color-bright:#fff;--color-synapse:#6366f1;--color-synapse-glow:#818cf8;--color-dream:#a855f7;--color-dream-glow:#c084fc;--color-memory:#3b82f6;--color-recall:#10b981;--color-decay:#ef4444;--color-warning:#f59e0b;--color-node-pattern:#ec4899}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;-moz-tab-size:4;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){-webkit-appearance:button;-moz-appearance:button;appearance:button}::file-selector-button{-webkit-appearance:button;-moz-appearance:button;appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}}@layer components;@layer utilities{.pointer-events-auto{pointer-events:auto}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.sticky{position:sticky}.inset-0{inset:calc(var(--spacing) * 0)}.inset-x-0{inset-inline:calc(var(--spacing) * 0)}.start{inset-inline-start:var(--spacing)}.end{inset-inline-end:var(--spacing)}.end\!{inset-inline-end:var(--spacing)!important}.top-0{top:calc(var(--spacing) * 0)}.top-0\.5{top:calc(var(--spacing) * .5)}.top-1{top:calc(var(--spacing) * 1)}.top-3{top:calc(var(--spacing) * 3)}.top-4{top:calc(var(--spacing) * 4)}.top-10{top:calc(var(--spacing) * 10)}.right-0{right:calc(var(--spacing) * 0)}.right-4{right:calc(var(--spacing) * 4)}.bottom-0{bottom:calc(var(--spacing) * 0)}.bottom-4{bottom:calc(var(--spacing) * 4)}.-left-\[29px\]{left:-29px}.left-1\/2{left:50%}.left-4{left:calc(var(--spacing) * 4)}.left-6{left:calc(var(--spacing) * 6)}.isolate{isolation:isolate}.z-10{z-index:10}.z-20{z-index:20}.z-40{z-index:40}.z-50{z-index:50}.z-\[1\]{z-index:1}.container{width:100%}@media(min-width:40rem){.container{max-width:40rem}}@media(min-width:48rem){.container{max-width:48rem}}@media(min-width:64rem){.container{max-width:64rem}}@media(min-width:80rem){.container{max-width:80rem}}@media(min-width:96rem){.container{max-width:96rem}}.mx-2{margin-inline:calc(var(--spacing) * 2)}.mx-auto{margin-inline:auto}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:calc(var(--spacing) * 1)}.mt-1\.5{margin-top:calc(var(--spacing) * 1.5)}.mt-2{margin-top:calc(var(--spacing) * 2)}.mt-3{margin-top:calc(var(--spacing) * 3)}.mt-4{margin-top:calc(var(--spacing) * 4)}.mt-\[-12px\]{margin-top:-12px}.mr-1{margin-right:calc(var(--spacing) * 1)}.mr-2{margin-right:calc(var(--spacing) * 2)}.mb-0\.5{margin-bottom:calc(var(--spacing) * .5)}.mb-1{margin-bottom:calc(var(--spacing) * 1)}.mb-1\.5{margin-bottom:calc(var(--spacing) * 1.5)}.mb-2{margin-bottom:calc(var(--spacing) * 2)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.mb-4{margin-bottom:calc(var(--spacing) * 4)}.ml-2{margin-left:calc(var(--spacing) * 2)}.ml-3{margin-left:calc(var(--spacing) * 3)}.ml-auto{margin-left:auto}.line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-4{-webkit-line-clamp:4;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.block{display:block}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-flex{display:inline-flex}.table{display:table}.aspect-square{aspect-ratio:1}.h-0\.5{height:calc(var(--spacing) * .5)}.h-1{height:calc(var(--spacing) * 1)}.h-1\.5{height:calc(var(--spacing) * 1.5)}.h-2{height:calc(var(--spacing) * 2)}.h-2\.5{height:calc(var(--spacing) * 2.5)}.h-3{height:calc(var(--spacing) * 3)}.h-4{height:calc(var(--spacing) * 4)}.h-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-12{height:calc(var(--spacing) * 12)}.h-14{height:calc(var(--spacing) * 14)}.h-16{height:calc(var(--spacing) * 16)}.h-20{height:calc(var(--spacing) * 20)}.h-24{height:calc(var(--spacing) * 24)}.h-28{height:calc(var(--spacing) * 28)}.h-32{height:calc(var(--spacing) * 32)}.h-40{height:calc(var(--spacing) * 40)}.h-\[520px\]{height:520px}.h-\[560px\]{height:560px}.h-full{height:100%}.h-px{height:1px}.h-screen{height:100vh}.max-h-48{max-height:calc(var(--spacing) * 48)}.max-h-64{max-height:calc(var(--spacing) * 64)}.max-h-72{max-height:calc(var(--spacing) * 72)}.max-h-96{max-height:calc(var(--spacing) * 96)}.max-h-\[620px\]{max-height:620px}.min-h-0{min-height:calc(var(--spacing) * 0)}.min-h-40{min-height:calc(var(--spacing) * 40)}.min-h-\[240px\]{min-height:240px}.min-h-\[320px\]{min-height:320px}.min-h-\[520px\]{min-height:520px}.min-h-full{min-height:100%}.w-1\.5{width:calc(var(--spacing) * 1.5)}.w-2{width:calc(var(--spacing) * 2)}.w-2\.5{width:calc(var(--spacing) * 2.5)}.w-3{width:calc(var(--spacing) * 3)}.w-4{width:calc(var(--spacing) * 4)}.w-5{width:calc(var(--spacing) * 5)}.w-6{width:calc(var(--spacing) * 6)}.w-7{width:calc(var(--spacing) * 7)}.w-8{width:calc(var(--spacing) * 8)}.w-9{width:calc(var(--spacing) * 9)}.w-12{width:calc(var(--spacing) * 12)}.w-14{width:calc(var(--spacing) * 14)}.w-16{width:calc(var(--spacing) * 16)}.w-20{width:calc(var(--spacing) * 20)}.w-24{width:calc(var(--spacing) * 24)}.w-32{width:calc(var(--spacing) * 32)}.w-96{width:calc(var(--spacing) * 96)}.w-\[3px\]{width:3px}.w-\[90\%\]{width:90%}.w-full{width:100%}.w-px{width:1px}.max-w-2xl{max-width:var(--container-2xl)}.max-w-4xl{max-width:var(--container-4xl)}.max-w-5xl{max-width:var(--container-5xl)}.max-w-6xl{max-width:var(--container-6xl)}.max-w-7xl{max-width:var(--container-7xl)}.max-w-20{max-width:calc(var(--spacing) * 20)}.max-w-\[220px\]{max-width:220px}.max-w-lg{max-width:var(--container-lg)}.max-w-md{max-width:var(--container-md)}.max-w-xl{max-width:var(--container-xl)}.max-w-xs{max-width:var(--container-xs)}.min-w-0{min-width:calc(var(--spacing) * 0)}.min-w-12{min-width:calc(var(--spacing) * 12)}.min-w-16{min-width:calc(var(--spacing) * 16)}.min-w-64{min-width:calc(var(--spacing) * 64)}.min-w-\[2rem\]{min-width:2rem}.min-w-\[3\.5rem\]{min-width:3.5rem}.flex-1{flex:1}.flex-shrink{flex-shrink:1}.flex-shrink-0{flex-shrink:0}.shrink{flex-shrink:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.border-separate{border-collapse:separate}.-translate-x-1\/2{--tw-translate-x: -50% ;translate:var(--tw-translate-x) var(--tw-translate-y)}.scale-125{--tw-scale-x:125%;--tw-scale-y:125%;--tw-scale-z:125%;scale:var(--tw-scale-x) var(--tw-scale-y)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.animate-\[fadeSlide_0\.35s_ease-out_both\]{animation:.35s ease-out both fadeSlide}.animate-ping{animation:var(--animate-ping)}.animate-pulse{animation:var(--animate-pulse)}.animate-spin{animation:var(--animate-spin)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.resize{resize:both}.resize-none{resize:none}.resize-y{resize:vertical}.appearance-none{-webkit-appearance:none;-moz-appearance:none;appearance:none}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.grid-cols-7{grid-template-columns:repeat(7,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-baseline{align-items:baseline}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-around{justify-content:space-around}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.gap-0{gap:calc(var(--spacing) * 0)}.gap-0\.5{gap:calc(var(--spacing) * .5)}.gap-1{gap:calc(var(--spacing) * 1)}.gap-1\.5{gap:calc(var(--spacing) * 1.5)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}.gap-4{gap:calc(var(--spacing) * 4)}.gap-5{gap:calc(var(--spacing) * 5)}.gap-6{gap:calc(var(--spacing) * 6)}.gap-\[2px\]{gap:2px}:where(.space-y-0\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * .5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * .5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1.5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1.5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 4) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 4) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 6) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-8>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 8) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 8) * calc(1 - var(--tw-space-y-reverse)))}.gap-x-6{column-gap:calc(var(--spacing) * 6)}.gap-y-1{row-gap:calc(var(--spacing) * 1)}.self-center{align-self:center}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:var(--radius-2xl)}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius-lg)}.rounded-md{border-radius:var(--radius-md)}.rounded-sm{border-radius:var(--radius-sm)}.rounded-xl{border-radius:var(--radius-xl)}.rounded-t{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.border{border-style:var(--tw-border-style);border-width:1px}.border-2{border-style:var(--tw-border-style);border-width:2px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.\!border-decay\/20{border-color:#ef444433!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)!important}}.\!border-decay\/30{border-color:#ef44444d!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/30{border-color:color-mix(in oklab,var(--color-decay) 30%,transparent)!important}}.\!border-decay\/40{border-color:#ef444466!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/40{border-color:color-mix(in oklab,var(--color-decay) 40%,transparent)!important}}.\!border-dream\/20{border-color:#a855f733!important}@supports (color:color-mix(in lab,red,red)){.\!border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)!important}}.\!border-synapse\/15{border-color:#6366f126!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)!important}}.\!border-synapse\/20{border-color:#6366f133!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)!important}}.\!border-synapse\/25{border-color:#6366f140!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/25{border-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)!important}}.\!border-synapse\/30{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.\!border-synapse\/40{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.border-\[\#A33FFF\]\/40{border-color:#a33fff66}.border-decay\/20{border-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.border-dream-glow\/40{border-color:#c084fc66}@supports (color:color-mix(in lab,red,red)){.border-dream-glow\/40{border-color:color-mix(in oklab,var(--color-dream-glow) 40%,transparent)}}.border-dream\/10{border-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.border-dream\/10{border-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.border-dream\/20{border-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.border-dream\/30{border-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.border-dream\/30{border-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.border-dream\/40{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.border-dream\/40{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.border-dream\/50{border-color:#a855f780}@supports (color:color-mix(in lab,red,red)){.border-dream\/50{border-color:color-mix(in oklab,var(--color-dream) 50%,transparent)}}.border-recall\/30{border-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.border-recall\/30{border-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.border-recall\/40{border-color:#10b98166}@supports (color:color-mix(in lab,red,red)){.border-recall\/40{border-color:color-mix(in oklab,var(--color-recall) 40%,transparent)}}.border-subtle\/15{border-color:#2a2a5e26}@supports (color:color-mix(in lab,red,red)){.border-subtle\/15{border-color:color-mix(in oklab,var(--color-subtle) 15%,transparent)}}.border-subtle\/20{border-color:#2a2a5e33}@supports (color:color-mix(in lab,red,red)){.border-subtle\/20{border-color:color-mix(in oklab,var(--color-subtle) 20%,transparent)}}.border-subtle\/30{border-color:#2a2a5e4d}@supports (color:color-mix(in lab,red,red)){.border-subtle\/30{border-color:color-mix(in oklab,var(--color-subtle) 30%,transparent)}}.border-synapse{border-color:var(--color-synapse)}.border-synapse\/5{border-color:#6366f10d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/5{border-color:color-mix(in oklab,var(--color-synapse) 5%,transparent)}}.border-synapse\/10{border-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.border-synapse\/10{border-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.border-synapse\/15{border-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.border-synapse\/20{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.border-synapse\/30{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.border-synapse\/40{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.border-transparent{border-color:#0000}.border-warning\/30{border-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.border-warning\/30{border-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.border-warning\/40{border-color:#f59e0b66}@supports (color:color-mix(in lab,red,red)){.border-warning\/40{border-color:color-mix(in oklab,var(--color-warning) 40%,transparent)}}.border-warning\/50{border-color:#f59e0b80}@supports (color:color-mix(in lab,red,red)){.border-warning\/50{border-color:color-mix(in oklab,var(--color-warning) 50%,transparent)}}.border-white\/5{border-color:#ffffff0d}@supports (color:color-mix(in lab,red,red)){.border-white\/5{border-color:color-mix(in oklab,var(--color-white) 5%,transparent)}}.border-t-dream{border-top-color:var(--color-dream)}.border-t-synapse{border-top-color:var(--color-synapse)}.border-t-warning{border-top-color:var(--color-warning)}.bg-\[\#A33FFF\]{background-color:#a33fff}.bg-\[\#A33FFF\]\/10{background-color:#a33fff1a}.bg-amber-400{background-color:var(--color-amber-400)}.bg-black\/40{background-color:#0006}@supports (color:color-mix(in lab,red,red)){.bg-black\/40{background-color:color-mix(in oklab,var(--color-black) 40%,transparent)}}.bg-decay{background-color:var(--color-decay)}.bg-decay\/10{background-color:#ef44441a}@supports (color:color-mix(in lab,red,red)){.bg-decay\/10{background-color:color-mix(in oklab,var(--color-decay) 10%,transparent)}}.bg-decay\/20{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.bg-decay\/20{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.bg-decay\/\[0\.05\]{background-color:#ef44440d}@supports (color:color-mix(in lab,red,red)){.bg-decay\/\[0\.05\]{background-color:color-mix(in oklab,var(--color-decay) 5%,transparent)}}.bg-deep{background-color:var(--color-deep)}.bg-deep\/40{background-color:#10102a66}@supports (color:color-mix(in lab,red,red)){.bg-deep\/40{background-color:color-mix(in oklab,var(--color-deep) 40%,transparent)}}.bg-deep\/60{background-color:#10102a99}@supports (color:color-mix(in lab,red,red)){.bg-deep\/60{background-color:color-mix(in oklab,var(--color-deep) 60%,transparent)}}.bg-dream{background-color:var(--color-dream)}.bg-dream\/5{background-color:#a855f70d}@supports (color:color-mix(in lab,red,red)){.bg-dream\/5{background-color:color-mix(in oklab,var(--color-dream) 5%,transparent)}}.bg-dream\/10{background-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.bg-dream\/10{background-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.bg-dream\/15{background-color:#a855f726}@supports (color:color-mix(in lab,red,red)){.bg-dream\/15{background-color:color-mix(in oklab,var(--color-dream) 15%,transparent)}}.bg-dream\/20{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.bg-dream\/20{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.bg-muted{background-color:var(--color-muted)}.bg-node-pattern{background-color:var(--color-node-pattern)}.bg-purple-500\/20{background-color:#ac4bff33}@supports (color:color-mix(in lab,red,red)){.bg-purple-500\/20{background-color:color-mix(in oklab,var(--color-purple-500) 20%,transparent)}}.bg-recall{background-color:var(--color-recall)}.bg-recall\/10{background-color:#10b9811a}@supports (color:color-mix(in lab,red,red)){.bg-recall\/10{background-color:color-mix(in oklab,var(--color-recall) 10%,transparent)}}.bg-recall\/15{background-color:#10b98126}@supports (color:color-mix(in lab,red,red)){.bg-recall\/15{background-color:color-mix(in oklab,var(--color-recall) 15%,transparent)}}.bg-recall\/20{background-color:#10b98133}@supports (color:color-mix(in lab,red,red)){.bg-recall\/20{background-color:color-mix(in oklab,var(--color-recall) 20%,transparent)}}.bg-synapse{background-color:var(--color-synapse)}.bg-synapse-glow{background-color:var(--color-synapse-glow)}.bg-synapse\/10{background-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/10{background-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.bg-synapse\/15{background-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/15{background-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.bg-synapse\/20{background-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/20{background-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.bg-synapse\/25{background-color:#6366f140}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/25{background-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)}}.bg-synapse\/70{background-color:#6366f1b3}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/70{background-color:color-mix(in oklab,var(--color-synapse) 70%,transparent)}}.bg-transparent{background-color:#0000}.bg-void{background-color:var(--color-void)}.bg-void\/60{background-color:#05051099}@supports (color:color-mix(in lab,red,red)){.bg-void\/60{background-color:color-mix(in oklab,var(--color-void) 60%,transparent)}}.bg-warning{background-color:var(--color-warning)}.bg-warning\/5{background-color:#f59e0b0d}@supports (color:color-mix(in lab,red,red)){.bg-warning\/5{background-color:color-mix(in oklab,var(--color-warning) 5%,transparent)}}.bg-warning\/20{background-color:#f59e0b33}@supports (color:color-mix(in lab,red,red)){.bg-warning\/20{background-color:color-mix(in oklab,var(--color-warning) 20%,transparent)}}.bg-white\/\[0\.02\]{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.02\]{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.bg-white\/\[0\.03\]{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.03\]{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.bg-white\/\[0\.04\]{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.04\]{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.bg-white\/\[0\.06\]{background-color:#ffffff0f}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.06\]{background-color:color-mix(in oklab,var(--color-white) 6%,transparent)}}.bg-gradient-to-br{--tw-gradient-position:to bottom right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.from-dream{--tw-gradient-from:var(--color-dream);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.to-synapse{--tw-gradient-to:var(--color-synapse);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.p-0{padding:calc(var(--spacing) * 0)}.p-0\.5{padding:calc(var(--spacing) * .5)}.p-1{padding:calc(var(--spacing) * 1)}.p-2{padding:calc(var(--spacing) * 2)}.p-2\.5{padding:calc(var(--spacing) * 2.5)}.p-3{padding:calc(var(--spacing) * 3)}.p-4{padding:calc(var(--spacing) * 4)}.p-5{padding:calc(var(--spacing) * 5)}.p-6{padding:calc(var(--spacing) * 6)}.p-10{padding:calc(var(--spacing) * 10)}.p-12{padding:calc(var(--spacing) * 12)}.px-1{padding-inline:calc(var(--spacing) * 1)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-2\.5{padding-inline:calc(var(--spacing) * 2.5)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.px-5{padding-inline:calc(var(--spacing) * 5)}.px-6{padding-inline:calc(var(--spacing) * 6)}.px-8{padding-inline:calc(var(--spacing) * 8)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1{padding-block:calc(var(--spacing) * 1)}.py-1\.5{padding-block:calc(var(--spacing) * 1.5)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-3{padding-block:calc(var(--spacing) * 3)}.py-4{padding-block:calc(var(--spacing) * 4)}.py-5{padding-block:calc(var(--spacing) * 5)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.py-10{padding-block:calc(var(--spacing) * 10)}.py-12{padding-block:calc(var(--spacing) * 12)}.py-20{padding-block:calc(var(--spacing) * 20)}.pt-1{padding-top:calc(var(--spacing) * 1)}.pt-2{padding-top:calc(var(--spacing) * 2)}.pt-3{padding-top:calc(var(--spacing) * 3)}.pt-4{padding-top:calc(var(--spacing) * 4)}.pt-6{padding-top:calc(var(--spacing) * 6)}.pt-8{padding-top:calc(var(--spacing) * 8)}.pt-\[10vh\]{padding-top:10vh}.pr-1{padding-right:calc(var(--spacing) * 1)}.pr-2{padding-right:calc(var(--spacing) * 2)}.pb-2{padding-bottom:calc(var(--spacing) * 2)}.pb-16{padding-bottom:calc(var(--spacing) * 16)}.pl-6{padding-left:calc(var(--spacing) * 6)}.pl-14{padding-left:calc(var(--spacing) * 14)}.text-center{text-align:center}.text-left{text-align:left}.text-right{text-align:right}.align-bottom{vertical-align:bottom}.align-top{vertical-align:top}.font-mono{font-family:var(--font-mono)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-3xl{font-size:var(--text-3xl);line-height:var(--tw-leading,var(--text-3xl--line-height))}.text-4xl{font-size:var(--text-4xl);line-height:var(--tw-leading,var(--text-4xl--line-height))}.text-5xl{font-size:var(--text-5xl);line-height:var(--tw-leading,var(--text-5xl--line-height))}.text-6xl{font-size:var(--text-6xl);line-height:var(--tw-leading,var(--text-6xl--line-height))}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[8px\]{font-size:8px}.text-\[9px\]{font-size:9px}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.leading-none{--tw-leading:1;line-height:1}.leading-relaxed{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.font-bold{--tw-font-weight:var(--font-weight-bold);font-weight:var(--font-weight-bold)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-\[0\.12em\]{--tw-tracking:.12em;letter-spacing:.12em}.tracking-\[0\.15em\]{--tw-tracking:.15em;letter-spacing:.15em}.tracking-\[0\.18em\]{--tw-tracking:.18em;letter-spacing:.18em}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.tracking-wide{--tw-tracking:var(--tracking-wide);letter-spacing:var(--tracking-wide)}.tracking-wider{--tw-tracking:var(--tracking-wider);letter-spacing:var(--tracking-wider)}.tracking-widest{--tw-tracking:var(--tracking-widest);letter-spacing:var(--tracking-widest)}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.text-\[\#E4C8FF\]{color:#e4c8ff}.text-amber-400{color:var(--color-amber-400)}.text-bright{color:var(--color-bright)}.text-decay{color:var(--color-decay)}.text-decay\/60{color:#ef444499}@supports (color:color-mix(in lab,red,red)){.text-decay\/60{color:color-mix(in oklab,var(--color-decay) 60%,transparent)}}.text-dim{color:var(--color-dim)}.text-dream{color:var(--color-dream)}.text-dream-glow{color:var(--color-dream-glow)}.text-dream\/40{color:#a855f766}@supports (color:color-mix(in lab,red,red)){.text-dream\/40{color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.text-dream\/80{color:#a855f7cc}@supports (color:color-mix(in lab,red,red)){.text-dream\/80{color:color-mix(in oklab,var(--color-dream) 80%,transparent)}}.text-memory{color:var(--color-memory)}.text-muted{color:var(--color-muted)}.text-muted\/50{color:#4a4a7a80}@supports (color:color-mix(in lab,red,red)){.text-muted\/50{color:color-mix(in oklab,var(--color-muted) 50%,transparent)}}.text-muted\/60{color:#4a4a7a99}@supports (color:color-mix(in lab,red,red)){.text-muted\/60{color:color-mix(in oklab,var(--color-muted) 60%,transparent)}}.text-node-pattern{color:var(--color-node-pattern)}.text-purple-400{color:var(--color-purple-400)}.text-recall{color:var(--color-recall)}.text-subtle{color:var(--color-subtle)}.text-synapse{color:var(--color-synapse)}.text-synapse-glow{color:var(--color-synapse-glow)}.text-text{color:var(--color-text)}.text-text\/80{color:#e0e0ffcc}@supports (color:color-mix(in lab,red,red)){.text-text\/80{color:color-mix(in oklab,var(--color-text) 80%,transparent)}}.text-warning{color:var(--color-warning)}.capitalize{text-transform:capitalize}.uppercase{text-transform:uppercase}.italic{font-style:italic}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.underline-offset-4{text-underline-offset:4px}.accent-synapse{accent-color:var(--color-synapse)}.accent-synapse-glow{accent-color:var(--color-synapse-glow)}.opacity-20{opacity:.2}.opacity-30{opacity:.3}.opacity-35{opacity:.35}.opacity-40{opacity:.4}.opacity-60{opacity:.6}.opacity-75{opacity:.75}.opacity-100{opacity:1}.shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow\!{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a)!important;box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)!important}.shadow-2xl{--tw-shadow:0 25px 50px -12px var(--tw-shadow-color,#00000040);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_10px_rgba\(239\,68\,68\,0\.7\)\]{--tw-shadow:0 0 10px var(--tw-shadow-color,#ef4444b3);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f126);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.18\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f12e);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(163\,63\,255\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#a33fff26);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(99\,102\,241\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#6366f14d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(168\,85\,247\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#a855f74d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a), 0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring,.ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-2{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-synapse\/10{--tw-shadow-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/10{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 10%, transparent) var(--tw-shadow-alpha), transparent)}}.shadow-synapse\/20{--tw-shadow-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/20{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 20%, transparent) var(--tw-shadow-alpha), transparent)}}.ring-dream-glow{--tw-ring-color:var(--color-dream-glow)}.ring-dream\/60{--tw-ring-color:#a855f799}@supports (color:color-mix(in lab,red,red)){.ring-dream\/60{--tw-ring-color:color-mix(in oklab, var(--color-dream) 60%, transparent)}}.ring-recall\/30{--tw-ring-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.ring-recall\/30{--tw-ring-color:color-mix(in oklab, var(--color-recall) 30%, transparent)}}.ring-synapse\/60{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.ring-synapse\/60{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.blur{--tw-blur:blur(8px);filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.backdrop-blur-md{--tw-backdrop-blur:blur(var(--blur-md));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-blur-sm{--tw-backdrop-blur:blur(var(--blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-filter{-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-200{--tw-duration:.2s;transition-duration:.2s}.duration-300{--tw-duration:.3s;transition-duration:.3s}.duration-500{--tw-duration:.5s;transition-duration:.5s}.duration-700{--tw-duration:.7s;transition-duration:.7s}.ease-in-out{--tw-ease:var(--ease-in-out);transition-timing-function:var(--ease-in-out)}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}.select-none{-webkit-user-select:none;user-select:none}.placeholder\:text-muted::placeholder{color:var(--color-muted)}@media(hover:hover){.hover\:z-10:hover{z-index:10}.hover\:scale-110:hover{--tw-scale-x:110%;--tw-scale-y:110%;--tw-scale-z:110%;scale:var(--tw-scale-x) var(--tw-scale-y)}.hover\:scale-\[1\.03\]:hover{scale:1.03}.hover\:\!border-synapse\/30:hover{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.hover\:\!border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.hover\:border-synapse\/20:hover{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/20:hover{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.hover\:border-synapse\/30:hover{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:border-synapse\/50:hover{border-color:#6366f180}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/50:hover{border-color:color-mix(in oklab,var(--color-synapse) 50%,transparent)}}.hover\:bg-decay\/20:hover{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/20:hover{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.hover\:bg-decay\/30:hover{background-color:#ef44444d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/30:hover{background-color:color-mix(in oklab,var(--color-decay) 30%,transparent)}}.hover\:bg-dream\/20:hover{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/20:hover{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.hover\:bg-dream\/30:hover{background-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/30:hover{background-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.hover\:bg-purple-500\/30:hover{background-color:#ac4bff4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-purple-500\/30:hover{background-color:color-mix(in oklab,var(--color-purple-500) 30%,transparent)}}.hover\:bg-recall\/30:hover{background-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-recall\/30:hover{background-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.hover\:bg-synapse\/30:hover{background-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-synapse\/30:hover{background-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:bg-warning\/30:hover{background-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-warning\/30:hover{background-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.hover\:bg-white\/\[0\.02\]:hover{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.02\]:hover{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.hover\:bg-white\/\[0\.03\]:hover{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.03\]:hover{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.hover\:bg-white\/\[0\.04\]:hover{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.04\]:hover{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.hover\:bg-white\/\[0\.08\]:hover{background-color:#ffffff14}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.08\]:hover{background-color:color-mix(in oklab,var(--color-white) 8%,transparent)}}.hover\:text-bright:hover{color:var(--color-bright)}.hover\:text-dim:hover{color:var(--color-dim)}.hover\:text-synapse-glow:hover{color:var(--color-synapse-glow)}.hover\:text-text:hover{color:var(--color-text)}.hover\:underline:hover{text-decoration-line:underline}}.focus\:\!border-synapse\/40:focus{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.focus\:\!border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.focus\:border-dream\/40:focus{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.focus\:border-dream\/40:focus{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.focus\:border-synapse\/40:focus{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.focus\:border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.focus\:ring-1:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-synapse-glow:focus{--tw-ring-color:var(--color-synapse-glow)}.focus\:ring-synapse\/20:focus{--tw-ring-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.focus\:ring-synapse\/20:focus{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 20%, transparent)}}.focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:#c084fc99}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-dream-glow) 60%, transparent)}}.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:#10b98199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-recall) 60%, transparent)}}.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-40:disabled{opacity:.4}.disabled\:opacity-50:disabled{opacity:.5}@media(min-width:40rem){.sm\:block{display:block}.sm\:inline-flex{display:inline-flex}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}}@media(min-width:48rem){.md\:block{display:block}.md\:flex{display:flex}.md\:hidden{display:none}.md\:inline-flex{display:inline-flex}.md\:min-w-\[340px\]{min-width:340px}.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.md\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.md\:grid-cols-5{grid-template-columns:repeat(5,minmax(0,1fr))}.md\:grid-cols-\[1fr_auto\]{grid-template-columns:1fr auto}.md\:grid-cols-\[280px_1fr\]{grid-template-columns:280px 1fr}.md\:flex-row{flex-direction:row}.md\:pt-\[15vh\]{padding-top:15vh}.md\:pb-0{padding-bottom:calc(var(--spacing) * 0)}}@media(min-width:64rem){.lg\:block{display:block}.lg\:w-56{width:calc(var(--spacing) * 56)}.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.lg\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.lg\:grid-cols-\[1fr_280px\]{grid-template-columns:1fr 280px}.lg\:grid-cols-\[1fr_340px\]{grid-template-columns:1fr 340px}.lg\:grid-cols-\[1fr_360px\]{grid-template-columns:1fr 360px}.lg\:grid-cols-\[minmax\(0\,1fr\)_340px\]{grid-template-columns:minmax(0,1fr) 340px}}.\[\&\:\:-webkit-slider-thumb\]\:h-3::-webkit-slider-thumb{height:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:w-3::-webkit-slider-thumb{width:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:appearance-none::-webkit-slider-thumb{-webkit-appearance:none;-moz-appearance:none;appearance:none}.\[\&\:\:-webkit-slider-thumb\]\:rounded-full::-webkit-slider-thumb{border-radius:3.40282e38px}.\[\&\:\:-webkit-slider-thumb\]\:bg-synapse-glow::-webkit-slider-thumb{background-color:var(--color-synapse-glow)}.\[\&\:\:-webkit-slider-thumb\]\:shadow-\[0_0_8px_rgba\(129\,140\,248\,0\.4\)\]::-webkit-slider-thumb{--tw-shadow:0 0 8px var(--tw-shadow-color,#818cf866);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}}html{background:var(--color-void);color:var(--color-text);font-family:var(--font-mono)}body{min-height:100vh;margin:0;overflow:hidden}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:var(--color-subtle);border-radius:3px}::-webkit-scrollbar-thumb:hover{background:var(--color-muted)}.glass{-webkit-backdrop-filter:blur(20px)saturate(180%);background:#16163873;border:1px solid #6366f114;box-shadow:inset 0 1px #ffffff08,0 4px 24px #0000004d}.glass-subtle{-webkit-backdrop-filter:blur(12px)saturate(150%);background:#10102a66;border:1px solid #6366f10f;box-shadow:inset 0 1px #ffffff05,0 2px 12px #0003}.glass-sidebar{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1a99;border-right:1px solid #6366f11a;box-shadow:inset -1px 0 #ffffff05,4px 0 24px #0000004d}.glass-panel{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1acc;border:1px solid #6366f11a;box-shadow:inset 0 1px #ffffff08,0 8px 32px #0006}.glow-synapse{box-shadow:0 0 20px #6366f14d,0 0 60px #6366f11a}.glow-dream{box-shadow:0 0 20px #a855f74d,0 0 60px #a855f71a}.glow-memory{box-shadow:0 0 20px #3b82f64d,0 0 60px #3b82f61a}@keyframes pulse-glow{0%,to{opacity:1}50%{opacity:.5}}.animate-pulse-glow{animation:2s ease-in-out infinite pulse-glow}@keyframes orb-float-1{0%,to{transform:translate(0)scale(1)}25%{transform:translate(60px,-40px)scale(1.1)}50%{transform:translate(-30px,-80px)scale(.95)}75%{transform:translate(-60px,-20px)scale(1.05)}}@keyframes orb-float-2{0%,to{transform:translate(0)scale(1)}25%{transform:translate(-50px,30px)scale(1.08)}50%{transform:translate(40px,60px)scale(.92)}75%{transform:translate(20px,-40px)scale(1.03)}}@keyframes orb-float-3{0%,to{transform:translate(0)scale(1)}25%{transform:translate(30px,50px)scale(1.05)}50%{transform:translate(-60px,20px)scale(.98)}75%{transform:translate(40px,-30px)scale(1.1)}}.ambient-orb{filter:blur(80px);pointer-events:none;z-index:0;opacity:.35;border-radius:50%;position:fixed}.ambient-orb-1{background:radial-gradient(circle,#a855f766,#0000 70%);width:400px;height:400px;animation:20s ease-in-out infinite orb-float-1;top:-10%;right:-5%}.ambient-orb-2{background:radial-gradient(circle,#6366f159,#0000 70%);width:350px;height:350px;animation:25s ease-in-out infinite orb-float-2;bottom:-15%;left:-5%}.ambient-orb-3{background:radial-gradient(circle,#f59e0b33,#0000 70%);width:300px;height:300px;animation:22s ease-in-out infinite orb-float-3;top:40%;left:40%}.nav-active-border{position:relative}.nav-active-border:before{content:"";background:linear-gradient(180deg,var(--color-synapse),var(--color-dream),var(--color-synapse));background-size:100% 200%;border-radius:1px;width:2px;animation:3s ease-in-out infinite gradient-shift;position:absolute;top:4px;bottom:4px;left:0}@keyframes gradient-shift{0%,to{background-position:0 0}50%{background-position:0 100%}}@keyframes float{0%,to{transform:translateY(0)translate(0)}25%{transform:translateY(-10px)translate(5px)}50%{transform:translateY(-5px)translate(-5px)}75%{transform:translateY(-15px)translate(3px)}}.retention-critical{color:var(--color-decay)}.retention-low{color:var(--color-warning)}.retention-good{color:var(--color-recall)}.retention-strong{color:var(--color-synapse)}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@keyframes spin{to{transform:rotate(360deg)}}@keyframes ping{75%,to{opacity:0;transform:scale(2)}}@keyframes pulse{50%{opacity:.5}}.toast-layer.svelte-pry2ep{position:fixed;z-index:60;pointer-events:none;display:flex;flex-direction:column;gap:.5rem;right:1.25rem;bottom:1.25rem;max-width:22rem;width:calc(100vw - 2.5rem)}@media(max-width:768px){.toast-layer.svelte-pry2ep{right:.75rem;left:.75rem;bottom:auto;top:.75rem;max-width:none;width:auto;align-items:stretch}}.toast-item.svelte-pry2ep{pointer-events:auto;position:relative;display:flex;gap:.75rem;align-items:stretch;text-align:left;font:inherit;color:inherit;background:#0c0e16b8;backdrop-filter:blur(14px) saturate(160%);-webkit-backdrop-filter:blur(14px) saturate(160%);border:1px solid rgba(255,255,255,.06);border-radius:.75rem;padding:.75rem .9rem .75rem .5rem;overflow:hidden;box-shadow:0 10px 40px -12px #000c,0 0 22px -6px var(--toast-color);cursor:pointer;animation:svelte-pry2ep-toast-in .32s cubic-bezier(.16,1,.3,1);transform-origin:right center;transition:transform .15s ease,box-shadow .15s ease}.toast-item.svelte-pry2ep:hover{transform:translateY(-1px) scale(1.015);box-shadow:0 14px 48px -12px #000000d9,0 0 32px -4px var(--toast-color)}.toast-item.svelte-pry2ep:focus-visible{outline:1px solid var(--toast-color);outline-offset:2px}.toast-accent.svelte-pry2ep{width:3px;border-radius:2px;background:var(--toast-color);box-shadow:0 0 10px var(--toast-color);flex-shrink:0}.toast-body.svelte-pry2ep{display:flex;flex-direction:column;gap:.15rem;flex:1;min-width:0}.toast-head.svelte-pry2ep{display:flex;align-items:center;gap:.5rem}.toast-icon.svelte-pry2ep{color:var(--toast-color);font-size:.95rem;text-shadow:0 0 8px var(--toast-color);line-height:1;width:1rem;display:inline-flex;justify-content:center}.toast-title.svelte-pry2ep{color:#f5f5fa;font-size:.82rem;font-weight:600;letter-spacing:.01em}.toast-sub.svelte-pry2ep{color:#b0b6c4;font-size:.74rem;line-height:1.35;padding-left:1.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.toast-progress.svelte-pry2ep{position:absolute;left:0;bottom:0;height:2px;width:100%;background:#ffffff0a}.toast-progress-fill.svelte-pry2ep{height:100%;background:var(--toast-color);opacity:.55;transform-origin:left center;animation:svelte-pry2ep-toast-progress var(--toast-dwell) linear forwards}.toast-item.svelte-pry2ep:hover .toast-progress-fill:where(.svelte-pry2ep),.toast-item.svelte-pry2ep:focus-visible .toast-progress-fill:where(.svelte-pry2ep){animation-play-state:paused}@keyframes svelte-pry2ep-toast-in{0%{opacity:0;transform:translate(24px) scale(.98)}to{opacity:1;transform:translate(0) scale(1)}}@media(max-width:768px){.toast-item.svelte-pry2ep{transform-origin:top center;animation:svelte-pry2ep-toast-in-mobile .3s cubic-bezier(.16,1,.3,1)}}@keyframes svelte-pry2ep-toast-in-mobile{0%{opacity:0;transform:translateY(-12px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}@keyframes svelte-pry2ep-toast-progress{0%{transform:scaleX(1)}to{transform:scaleX(0)}}@media(prefers-reduced-motion:reduce){.toast-item.svelte-pry2ep{animation:none}.toast-progress-fill.svelte-pry2ep{animation:none;transform:scaleX(.5)}}.strip-item.svelte-1kk3799{display:inline-flex;align-items:center;gap:.4rem;padding:0 .75rem;white-space:nowrap;flex-shrink:0}.strip-divider.svelte-1kk3799{width:1px;height:14px;background:#6366f11f;flex-shrink:0}.ambient-strip.ambient-flash.svelte-1kk3799{background:linear-gradient(90deg,#ef444414,#ef444400 70%),#0006;border-bottom-color:#ef444459;transition:background .3s ease,border-color .3s ease}@keyframes svelte-1kk3799-ping-slow{0%{transform:scale(1);opacity:.8}80%,to{transform:scale(2);opacity:0}}.animate-ping-slow{animation:svelte-1kk3799-ping-slow 2.2s cubic-bezier(0,0,.2,1) infinite}@media(prefers-reduced-motion:reduce){.ambient-strip.svelte-1kk3799 .animate-ping,.ambient-strip.svelte-1kk3799 .animate-ping-slow,.ambient-strip.svelte-1kk3799 .animate-pulse{animation:none!important}}.theme-toggle.svelte-1cmi4dh{width:30px;height:30px;display:inline-flex;align-items:center;justify-content:center;padding:0;border-radius:8px;background:#6366f10f;border:1px solid rgba(99,102,241,.14);color:var(--color-text);cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease,transform .12s ease;-webkit-tap-highlight-color:transparent}.theme-toggle.svelte-1cmi4dh:hover{background:#6366f124;border-color:#6366f14d;color:var(--color-bright)}.theme-toggle.svelte-1cmi4dh:active{transform:scale(.94)}.theme-toggle.svelte-1cmi4dh:focus-visible{outline:1px solid var(--color-synapse);outline-offset:2px}.icon-wrap.svelte-1cmi4dh{position:relative;width:18px;height:18px;display:inline-block}.icon.svelte-1cmi4dh{position:absolute;top:0;right:0;bottom:0;left:0;width:18px;height:18px;opacity:0;transform:scale(.7) rotate(-30deg);transition:opacity .2s ease,transform .2s cubic-bezier(.16,1,.3,1);pointer-events:none}.icon.active.svelte-1cmi4dh{opacity:1;transform:scale(1) rotate(0)}.theme-toggle[data-mode=dark].svelte-1cmi4dh{color:var(--color-synapse-glow, #818cf8)}.theme-toggle[data-mode=light].svelte-1cmi4dh{color:var(--color-warning, #f59e0b)}.theme-toggle[data-mode=auto].svelte-1cmi4dh{color:var(--color-dream-glow, #c084fc)}@media(prefers-reduced-motion:reduce){.theme-toggle.svelte-1cmi4dh,.icon.svelte-1cmi4dh{transition:none}}.safe-bottom.svelte-12qhfyh{padding-bottom:env(safe-area-inset-bottom,0px)}@keyframes svelte-12qhfyh-page-in{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}.animate-page-in.svelte-12qhfyh{animation:svelte-12qhfyh-page-in .2s ease-out} diff --git a/apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css.br b/apps/dashboard/build/_app/immutable/assets/0.IIz8MMYb.css.br deleted file mode 100644 index 8739b098544269cba2a72cb06f40263c9fe45be2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9720 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 XTGyt`=D3h{`7i$uE_su9Tm}IEqmv&Q diff --git a/apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js b/apps/dashboard/build/_app/immutable/chunks/554JRhq6.js similarity index 86% rename from apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js rename to apps/dashboard/build/_app/immutable/chunks/554JRhq6.js index 8ce57c7..dc7f822 100644 --- a/apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js +++ b/apps/dashboard/build/_app/immutable/chunks/554JRhq6.js @@ -1 +1 @@ -const r="/api";async function t(e,o){const i=await fetch(`${r}${e}`,{headers:{"Content-Type":"application/json"},...o});if(!i.ok)throw new Error(`API ${i.status}: ${i.statusText}`);return i.json()}const n={memories:{list:e=>{const o=e?"?"+new URLSearchParams(e).toString():"";return t(`/memories${o}`)},get:e=>t(`/memories/${e}`),delete:e=>t(`/memories/${e}`,{method:"DELETE"}),promote:e=>t(`/memories/${e}/promote`,{method:"POST"}),demote:e=>t(`/memories/${e}/demote`,{method:"POST"}),suppress:(e,o)=>t(`/memories/${e}/suppress`,{method:"POST",body:o?JSON.stringify({reason:o}):void 0}),unsuppress:e=>t(`/memories/${e}/unsuppress`,{method:"POST"})},search:(e,o=20)=>t(`/search?q=${encodeURIComponent(e)}&limit=${o}`),stats:()=>t("/stats"),health:()=>t("/health"),timeline:(e=7,o=200)=>t(`/timeline?days=${e}&limit=${o}`),graph:e=>{const o=e?"?"+new URLSearchParams(Object.entries(e).filter(([,i])=>i!==void 0).map(([i,s])=>[i,String(s)])).toString():"";return t(`/graph${o}`)},dream:()=>t("/dream",{method:"POST"}),explore:(e,o="associations",i,s=10)=>t("/explore",{method:"POST",body:JSON.stringify({from_id:e,action:o,to_id:i,limit:s})}),predict:()=>t("/predict",{method:"POST"}),importance:e=>t("/importance",{method:"POST",body:JSON.stringify({content:e})}),consolidate:()=>t("/consolidate",{method:"POST"}),retentionDistribution:()=>t("/retention-distribution"),intentions:(e="active")=>t(`/intentions?status=${e}`),deepReference:(e,o=20)=>t("/deep_reference",{method:"POST",body:JSON.stringify({query:e,depth:o})})};export{n as a}; +const r="/api";async function t(e,o){const i=await fetch(`${r}${e}`,{headers:{"Content-Type":"application/json"},...o});if(!i.ok)throw new Error(`API ${i.status}: ${i.statusText}`);return i.json()}const n={memories:{list:e=>{const o=e?"?"+new URLSearchParams(e).toString():"";return t(`/memories${o}`)},get:e=>t(`/memories/${e}`),delete:e=>t(`/memories/${e}`,{method:"DELETE"}),promote:e=>t(`/memories/${e}/promote`,{method:"POST"}),demote:e=>t(`/memories/${e}/demote`,{method:"POST"}),suppress:(e,o)=>t(`/memories/${e}/suppress`,{method:"POST",body:o?JSON.stringify({reason:o}):void 0}),unsuppress:e=>t(`/memories/${e}/unsuppress`,{method:"POST"})},search:(e,o=20)=>t(`/search?q=${encodeURIComponent(e)}&limit=${o}`),stats:()=>t("/stats"),health:()=>t("/health"),timeline:(e=7,o=200)=>t(`/timeline?days=${e}&limit=${o}`),graph:e=>{const o=e?"?"+new URLSearchParams(Object.entries(e).filter(([,i])=>i!==void 0).map(([i,s])=>[i,String(s)])).toString():"";return t(`/graph${o}`)},dream:()=>t("/dream",{method:"POST"}),explore:(e,o="associations",i,s=10)=>t("/explore",{method:"POST",body:JSON.stringify({from_id:e,action:o,to_id:i,limit:s})}),predict:()=>t("/predict",{method:"POST"}),importance:e=>t("/importance",{method:"POST",body:JSON.stringify({content:e})}),consolidate:()=>t("/consolidate",{method:"POST"}),retentionDistribution:()=>t("/retention-distribution"),intentions:(e="active")=>t(`/intentions?status=${e}`),deepReference:(e,o=20)=>t("/deep_reference",{method:"POST",body:JSON.stringify({query:e,depth:o})}),sanhedrin:{latest:()=>t("/sanhedrin/latest"),appeal:(e,o,i,s)=>t("/sanhedrin/appeal",{method:"POST",body:JSON.stringify({reason:e,note:o,claimId:i,receiptId:s})})}};export{n as a}; diff --git a/apps/dashboard/build/_app/immutable/chunks/554JRhq6.js.br b/apps/dashboard/build/_app/immutable/chunks/554JRhq6.js.br new file mode 100644 index 0000000000000000000000000000000000000000..05230405e0e28e40e1e6f9d92752229ed2670732 GIT binary patch literal 632 zcmV-;0*Cz@rUn3v)LN}JY}?Z5-eq!BvaX6CcrkBTwW);V6(-;jxJ*`NE$v{R2Q7mEx{^1`O{If51+zWT>jTzkbu`zIj7?6 z??@s8M3G$Pbs6Z3qZGYHr*93pi!GK3VMhYU050s5a-N-GHPQ_@63qL1lFM7CXQ;sN zbYQE8Ls~s_42w_XeA?GLb=C7J5OBO4`@Q7EYLvI}E>G~!a&+W^bJ@8gtwLP=MeK0X zM@+jDq|qTDm#&!M?$2b~55F-*KhaA`@{vfk(BwP-6H1C7ko1PJ@EzQt0zmD^ajtR~ zGd)tS(AOgvf3LXcU;;(~F|560weYYju7w+K^Ea{&l%91&(lLX@e>3HIjTT4nn?Uo{ z1%4n>kx2A~tT)SGM41DqAQl)Mwgh?$SxiO?xey3(JRh*p^8}4g!I!nHWMi@%X&H&8 zQ5qKW!qJh6cT7-1>-X$1+ICj=j5-Rjh^e!n*vW8c1T&RPf=+rrDU7)Wab+>IHpwo` z#b&oXa^Tf!L0BM60&^_GvBQDXH*Tuf5tmNOFS^yifRb;1&5xr=08|Y0u~K2%N!eZ|rOK)a`oM$+qUC8q)FfAW zEU|;_0#%g%zO$3G6_lw@iSP5>eRucyG9`@-bjpUJLN*d+Ewf;;l9@#%0~-QYQJwiq zn2HyHHduhomf?I*>t;|xGw1aZL=M^{H9J+(g0#o8bp;n#JMTr~!06yw2H1th~cn$?v*pG5zW|t~Y*xBS_GMlg_;+0mV`oLk>fjf>@m(!VZ z%i&|M7Te=wR#m0Jn8eR>pKE{Ptuwz@`8rYKU(?IqGzHfrT&%-dgP`6gG|J>zVIG`N zmX+M(*-LMWzo*!6<7eU-rr%CFlC5$4lu`hhsT^*u&relZDM>1$$u*w~EYYUze7KVd z73rPX(4SbuNuGsWZp`hG>=sKXPy*#lzx%9x+8!C_Vr^XRH+deksFnxH>+=2)G8+?L z*9oV#1r`=`82;gSO9}BPP1_zuaVaXYBR3A9ZzoF=-A4aWsi)IRG^f#&n_~Tmy;lUh zR)x~gwwnoKREGYY8pbJo`t_s>&|PGEb@5ge3zF>}<_U1&7f7PGRnCCi_b)LtX(xTi zF|!+z-FXj9q)}@tWY#I34Y!uVC}r(NO2B7!<5C6Yf}T*HeaE(k0kxUjsg^TzQSVp2 zuHJWp9_KqSX$xfsxHm@)rgl67>*Tcs$L(TEH#-EXYgm8=SMlysph*&Tr+e_Q;-6Na z*EEeBDtZ9Qx4;Owgq*I>lBAN&b_^S2*aB1rEpU1*o{5viyNfM;7@2Nm0GDooDV`Mq m%X6m<4H;l%>EG+4X-1?vnsO}zVFJ;NKK%os^qu~{`HTKh zV->ycGQr{Zry!`gql+@Z-+p|^L>)JWP?_;lQkL`#pZLNP> zBfGYuEsGDtv1P4`-`1sl{TWIPmbZ-+Z2y_R*0155P0?eioi(>Nma_j^&gRdYSx4*I z-llXrA9{|>hx1vDGQ8P&8j?5k10(@!#0kRIrJ$0X0f}P2qMDhYC(1H)!mk@x9oF5> z-9F^YRk?09??#hcPtO^wK2#puU#6&Nw%*<2A>st%liOm7BfflBxZFFgjEERPwMkgq z{O)J3ifyApL}N8kP4lB#f6SOtCl4e_RO? zlw|~&m9&pw#Pt~L2ag=zr`;e}hb+fhCP@_xZIdjOZKqwu4-s?oS(oST23MjlYDUoQLKgv2(x++88^@VWs@P^EN^ny2z5@l2j*3x79(k2 zFDvOV)>Hi&?)f3#msE&hI8b@#(z{J@10rRxuNx08+9rEA5P6O)lxal)SG0FZvRq$CycGRrKI5hGH`Y~NSmZQ_T8r`0s zzdIWJkaXL|K7PcoFQ8142HhQsC+00H6PHgVb(F2ROfS6DxwS2Y@R1d`qM}a*#`e5*bF7Z@IclNf@kq zk%qHI0qN?6r7yMmSw9xB>F36jOSZdYTzU>z&e^8j@sITBd`>=!6%*MPQfkN2O}z1F-VPQBy91 z17<^TJ>lYfZ@@H&z$T4+G~5NK_ipJUqj2G}GKHc8x|Kul(61An3N=UqH#aGeH-!}d z$5N$CAW=ttNWVyB{6aQ&PAmA%<9S}=w#Z6+1|=%VIJ{ESy&ILeLRb>NR{!rHteAf@ z%QktQ?3r#hb5bka2P-x`IJ|u-ZIa)+A1?HG8nF|8^)8C^-Aw;Cv-rirUd^X7IBYi6 zYq+;IiNTVc84c4ka<^vIj?qY3aTNnY`TS^Tp(H?)oG;RlCLZ+wS@#hD67XfSn$IO2 z&3MF0#!*jx9Gb7+t#L?Ls5R85u@p5`Q)#8B)JgitO6>V%SG-uAD0N3dvBBwU z-pB+kls?lQ1`{IeBiEF1Pe?rYr&3Jz3Z{T1`sYD@OV!1~Zzml_iLfjr%m|yTpGxM6 zzKcwUFErTh-Dy@)3hVfX5$s4Cm$zJJBX?)ZlQpg;B;DI>0htI0_axHf)Dun(yGW(p z7Tg5myc^WJ&)2?Vo~yBnu#~g1KQ6Z`uG1gC#oGB56xd90p~58&;toP^rn^MK-IMPv z8f#;H!xby*wR&3mq~|}fCDW{O%dJ|sSgml8d%0z-8)fnA7+uo0q33YTD{3M5P2@qQ zH{^BYwi7KZh6(~}A!d|Er$ra{qrNa(Hg%qh{^EoPMjK6WhR8hsk%`hoA%Oc3@D1Ks zqEz@UcU4<@yy%`i%i}e&`1`O&>zuc|B1B3eP*x8q-~@$S0z+w|L?zh!k`5l|!QH@oL9h>BpwK*uTeUA;O_L|AY$5z-7fdf2r* zx#ALJRtOyX*O>kF$VdIT_S`?NJ*+tI6o8GTO)y*u174sY*z@ViQqWj@s8=v*tKKA7 z2R|@|P;aWjT$xfN2m=tN$}dp;a(J7Zyc=_U`cd*LAlI$tckg1Hw-A=&p^8U1a`*5# zjsaevpD#zxCu@5Cc9|-3e-F~Do)1=^Ms%qVAcz=={x5PSHZs+Bf4kqDVn>P|f}tl(VyDbDS8iJ;{JH(G z3cN~rX{{S#Jt=Z;$@5wk`6gxy?9EV09==S8n%_utW@@N~5F9 zXctjP%F9vN=Q#f3VC)i)F!u(c6sL0zzD!OKZuGheZJyV>P-yPI{i!HtKji!?z5v!qV|2p9QKSvpupzr$*g{3P4GsV_9Y$5 zvx0#uHn3bbay9o9;OH)e-2sp!Y)M!oqP9Ob+Q{{sFs+Gm zS^!k2LYJ}YU*1No#s&s%^aRj=GQfs-#@=8iDI*ah-j$U!8OVBZV?qK8_=Rzwf52(* zb2Ik))7fi57fL($_kQqb7m$6!skP)8Y#aIJI+EAXEf|{@f%|qpAdOPXY)-||iN*Yq zKh&W@!yINELQjmhaH54BnM$?e7+akY`>4R(^>IG(hQPPzyYM)gZWCoZ{m&ydaLxT^ zd>!^#^KUg2-Wg!?M6AX@F`B<=LwGMUoUn)GArvLdk`7NZ_(UYcRXc8x+4GM{Z71wGQw9qq!Z;)M8||gVsL=6qr!D zuMwhQ-v=CLQnbX%K;OhCi;UV?@Z8_XQdr_Lv{G{=7;v0BF9hD0F`Oy;Eh2BPkmhcd z?KD4%i5UvPfN3v?UC@sr>sw&gm`{(JcSlpY076@9{n~sAVooIg$(ro5LsFqZO7T0;w=N?hVNX5n zHHz*Sqi8u@)w>t(gZp0E1iJh@SUSFTb0ydHu#}v6WsAxxLd(iRby=oPPRh#|Rcu3|J;Ieu>%0(L_)YdtzM6I``IguB_c?yc+?U zlepqil2(;p00nrZ>zo+M)Xypv)8HzmVGyB;Vq*x|rt#d9(({>98A*;iRA{20vO^47 z=PA+^0(X71X;&vF(AL~T_(pG15A)q7%S?TSQqpY8U%T%1UxY#;T!a;Kpo7Bi15$4! zg<5EaJhVP!g5TnY%o+=bfWpJV(-9H3c!mfhVNM}xUdv-MV2Wsovn>$kU8~jYP(kyrq*;lV?G=boUd@u_#6XoQ`6WQR*1A3?q?U$tNAYYT= z3_gN#Hl-lMZ36fAQ>TCA8W8jDmWe{wIzAq+vzEb__i9Y+z9Gi1w*ptc^+4G8GuY_sn6qM987%R_%BI~~m- z!UmeJAh+AISY?fV!31gw{0AYx@7ZvEk6NRnbKI_|sYV4$&Z;xs)E(AUY_}taDYuQT z2pagN51z{siueZWABzk|f@JN%CT+=f9v3C$30Y=3-DL?7i^57NM=9X2QezQe2Xs-h z^$F!fL><~wiBxZ*SS?W#@cu1B1buT#eQ2luXS`ALIiVS8*fE=^R~3ax=%7Da6XyLb z(~6d=Yp82Q9KebkTf&d(4fENhhP{QBo6XJkw#`f)gHzL4GJ8|CTULD*ZHqJv(ZpnjU2m@Nh9&qkTT1q)VY#|d?{4DOuHk9{ zOM5-|`R#rx=g+x)R_z6@YzItVt6Vp4&EuX!92MpM4_De)bkCepl-4$fd`!5AT04)m zrBg-*TpFH%akq00-RrH_zhbXvMhlCEv(<$cYOi#I{t7gT97j4jOn5}c92`ZK)HG=H z#Ja11DugkG(bc5fvQ?sHsRN5tCWrTyAQV+;e7y14N!as_k8*Zp;W2SZd^UAe@71IV zau7|=KN&!TdMwx@t{U|<@f72;(hJu&eArrCpDPu{wURuGs}sUK!OBv@xuF(6T(0;J zXa3lDlWp~%l@y&uiSG}R)|BCmlRfVYZK=aZShk|60H(4FBNtMHRjP*JM+iFtg+e$q zKj_S|o3%^soZ7DV(kJ^mJ|A72_B<&4=tb1Y9HQRWh14yKFNg3j!6-IH0v>tTBTV-5 z2wKr3b@P~Y)ABe`0G6P~%DCV#9{4%X4&U%uz+rJQ5>6N}M(Y@Vj)2J0p_9MKbhq~+P#o#R5$HmP(@Y<$L)>p+U5nxDY!L;9EiRb=B}!7N^pGojjeXZb3vPsT*kx8FmtGPYAV3{{xqrF&C^=MKHkS&F z*qc~=Gd2V=CH+ulGZ)FzQt?9K82axg14M5a@sM=*wCQsk`|8tsvmvw-ZeX{{HrAYk zS2J#3awglL z5|Qi5S!L6j4MuMSqf&9*XMzp@4{;0eb&D{26~~-}itF?fR9L18uk=I8Lby^#5tt)< zzGtlUxw$GluF&5A6IG1@5*S3emcFs@PQYX4H zIP94;!3Y#E$eKqu!fZ*bar|`i846xK7AX_{V^mkcy!@jd{LNEj6SOKOhf&62Ie^^{ z8%rPA&w@*hi~gx-i7UbU_=YY0Yb~ro|Jm&7hAUL(N+E8D5l;Q`?XiMTpUoTL_D;p+=)nl_B|F*Uf_rCQ;VBAFm!{!LO_j%VwsY|x%SR_#2P6Nsxtu;Z& zj>G!oyqnk{cep6}Ad%<1P^11>_5<%V03M=EuD{}w?_IhcWmuK@12mz`0c6|pm&a;V zIyR^8nW`3Yv%kW9BIoVE!|gA~6$v?}cXQL;gi6y}!G5xJv4>8^%Ns{k1K@0}0VO3) z%L`lE_q2KHk*u$PPE-NlYmJCc%8i)#3yq>`y5!Qjb%T8)Lz+~h4?AaBuLbk7B$z|0 z8QyF?Vm;U8Sv{gpI_58yWvFUn{Z^#t9UJ%RTi&w1-5+0cA1fMqIf$M;Iv$Pbg8+6h z9^5lz3uQBbGO<0Y0@#zcZ1WQY`r6DFMlQ0va|KrZ;WT|Pr)mi0&XAe~I3~Np< z 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 T$#i5#UvfWmMZ(5b6-4<5Lp~z+ diff --git a/apps/dashboard/build/_app/immutable/chunks/BdslOLCg.js.gz b/apps/dashboard/build/_app/immutable/chunks/BdslOLCg.js.gz deleted file mode 100644 index 9f556516ba76163f340db32365fa71dda6c051ea..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2953 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 diff --git a/apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js b/apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js deleted file mode 100644 index 809f3b1..0000000 --- a/apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js +++ /dev/null @@ -1 +0,0 @@ -import{w as S,g as T}from"./BeMFXnHE.js";import{e as R}from"./MAY1QfFZ.js";import{E as u}from"./DzfRjky4.js";const M=4,x=1500;function F(){const{subscribe:y,update:i}=S([]);let m=1,b=0;const d=new Map,a=new Map,l=new Map;function f(e,o){l.set(e,Date.now());const t=setTimeout(()=>{d.delete(e),l.delete(e),g(e)},o);d.set(e,t)}function w(e){const o=m++,t=Date.now(),s={id:o,createdAt:t,...e};i(n=>{const r=[s,...n];return r.length>M?r.slice(0,M):r}),f(o,e.dwellMs)}function g(e){const o=d.get(e);o&&(clearTimeout(o),d.delete(e)),a.delete(e),l.delete(e),i(t=>t.filter(s=>s.id!==e))}function C(e,o){const t=d.get(e);if(!t)return;clearTimeout(t),d.delete(e);const s=l.get(e)??Date.now(),n=Date.now()-s,r=Math.max(200,o-n);a.set(e,{remaining:r})}function D(e){const o=a.get(e);o&&(a.delete(e),f(e,o.remaining))}function N(){for(const e of d.values())clearTimeout(e);d.clear(),a.clear(),l.clear(),i(()=>[])}function _(e){const o=u[e.type]??"#818CF8",t=e.data;switch(e.type){case"DreamCompleted":{const s=Number(t.memories_replayed??0),n=Number(t.connections_found??0),r=Number(t.insights_generated??0),p=Number(t.duration_ms??0),c=[];return c.push(`Replayed ${s} ${s===1?"memory":"memories"}`),n>0&&c.push(`${n} new connection${n===1?"":"s"}`),r>0&&c.push(`${r} insight${r===1?"":"s"}`),{type:e.type,title:"Dream consolidated",body:`${c.join(" · ")} in ${(p/1e3).toFixed(1)}s`,color:o,dwellMs:7e3}}case"ConsolidationCompleted":{const s=Number(t.nodes_processed??0),n=Number(t.decay_applied??0),r=Number(t.embeddings_generated??0),p=Number(t.duration_ms??0),c=[];return n>0&&c.push(`${n} decayed`),r>0&&c.push(`${r} embedded`),{type:e.type,title:"Consolidation swept",body:`${s} node${s===1?"":"s"}${c.length?" · "+c.join(" · "):""} in ${(p/1e3).toFixed(1)}s`,color:o,dwellMs:6e3}}case"ConnectionDiscovered":{const s=Date.now();if(s-b0?`suppression #${s} · Rac1 cascade ~${n} neighbors`:`suppression #${s}`,color:o,dwellMs:5500}}case"MemoryUnsuppressed":{const s=Number(t.remaining_count??0);return{type:e.type,title:"Recovered",body:s>0?`${s} suppression${s===1?"":"s"} remain`:"fully unsuppressed",color:o,dwellMs:5e3}}case"Rac1CascadeSwept":{const s=Number(t.seeds??0),n=Number(t.neighbors_affected??0);return{type:e.type,title:"Rac1 cascade",body:`${s} seed${s===1?"":"s"} · ${n} dendritic spine${n===1?"":"s"} pruned`,color:o,dwellMs:6e3}}case"MemoryDeleted":return{type:e.type,title:"Memory deleted",body:String(t.id??"").slice(0,8),color:o,dwellMs:4e3};case"Heartbeat":case"SearchPerformed":case"RetentionDecayed":case"ActivationSpread":case"ImportanceScored":case"MemoryCreated":case"MemoryUpdated":case"DreamStarted":case"DreamProgress":case"ConsolidationStarted":case"Connected":return null;default:return null}}let h=null;return R.subscribe(e=>{if(e.length===0)return;const o=[];for(const t of e){if(t===h)break;o.push(t)}if(o.length!==0){h=e[0];for(let t=o.length-1;t>=0;t--){const s=_(o[t]);s&&w(s)}}}),{subscribe:y,dismiss:g,clear:N,pauseDwell:C,resumeDwell:D,push:w}}const $=F();function O(){[{type:"DreamCompleted",title:"Dream consolidated",body:"Replayed 127 memories · 43 new connections · 5 insights in 2.4s",color:u.DreamCompleted,dwellMs:7e3},{type:"ConnectionDiscovered",title:"Bridge discovered",body:"semantic · weight 0.87",color:u.ConnectionDiscovered,dwellMs:4500},{type:"MemorySuppressed",title:"Forgetting",body:"suppression #2 · Rac1 cascade ~8 neighbors",color:u.MemorySuppressed,dwellMs:5500},{type:"ConsolidationCompleted",title:"Consolidation swept",body:"892 nodes · 156 decayed · 48 embedded in 1.1s",color:u.ConsolidationCompleted,dwellMs:6e3}].forEach((i,m)=>{setTimeout(()=>{$.push(i)},m*800)}),T($)}export{O as f,$ as t}; diff --git a/apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js.br b/apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js.br deleted file mode 100644 index 30bed5644ca4ff318a44168e7aa9e37ff677032e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1513 zcmVs@lu1C8{X3nnQDtt81cyU)?axaus(Mmkk-3Yp>{UMay_GU2_criMSner2%w6!juR@f&xF(Ltv)IVi@p%Cm<1 zPyk`A4}`A4YDan3Xo`C)22`IN{UZrpNJ{T;w3HN-Ro<>jcO+`{CwRK2_ zPcC~KP@m6j%tSSmd#-QkH-9R|UryCqE!B|k7jDvmyw~79SQi01<&brgKi2OvHFo!Z zSL>dGV#xHwgktH#$^inq8^99sL81cXVfoScV^6u)QjZWZ#H+1hn%-;zX7{21ssJXz zJ}`Pzd3y1^z9=v_ALu;U^Vm{vj6X3}pK8V!biD?$k}PJ&yckbHA{VS7#;yXelMG|( zU;vc42kO|^xmH~Uap*cxFPs}20l zDCB6Gq^ldL)D!Eb3RTA0nsSCbHdLNvbDMnPWfa>9r&MHBtDyT|*vYn)9cynhHsE{w^=#uPL|h1AfLul`7@4TNq{|0D_RVyt6)Gl+A!30_AxvTgnxT%SchG%FzvA6 zT843kVXDI_Go*WAF1AKWT@+G+S-E)%@rKTYXQX`y+*ND0{f-uw)m{%J7o0N<*i=QZM2*;VWdB>g6T4HMRAKVpo*Ym7G3u7K5fxZQPe4wRaq)~qU1 zT7%8W%%U*;Ft=if!0l#Vqkw5=_ P2s`X`hhw7TtvqG{R_N*P diff --git a/apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js.gz b/apps/dashboard/build/_app/immutable/chunks/BjdL4Pm2.js.gz deleted file mode 100644 index 78fece5f53f1210e379543267f30042b802416e8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1645 zcmV-z29o(7iwFP!000026RlWVZ`(E$e&4T9)hv)&MYYqU_2el=8#m}4+;(vbYzqQM zmX2(uk|>Z=9naAI*53Eab|~szdq(6qp@y3 zdkvF|-;%d)>|3r6i6R6^aamDJUj5$xHN5zvP4PxjWEI8u&+zj0^ZKNq@M*$@HgQj^ zJGXz@>kY#!@dcrYc43&C;&j8aIrkZvgR{1>H1GsCBzLFA)wMZ{Kxnbsx8`oIkx61I>hCnC{soumeDOV1Q{w zt@Q#wa%46PN@l{$YdI@CRCZ|8jh{ZXgxkonxVs^NLoJ^HZU(P}BP`ptAs-SWL6Pbr zbFaAEPOgUxM8*=0*%2fQu{@iMn9U>NgVD1lro(d63Jq$39jqXVCcLG|qOD0_FQlsG zkRBcyegqz?Or@sPGSsxZuUJhC;hqUQB#{7SaQBScBzWYyc&Cwhu28NJt)-ICcqB|^ z%&;R~bi|jw;BHjj9F1D&B`qkAxW(LwCzf{X-5JNdo<)xmbLf>W*)WJbl8|H}F=`YX zw?XmRptS8Sg2k>`v@LvxVH#3qC?25EPz&rYUX%gHSn8MtGD3NJP!I8<0?LPcj40=$txp$wmeG)oi#YY0ff$zmz^Yyk-{8O8-g z+E4@;ZX<(P%!?!6y{aSGx6_O-jho9-ymqkRx%_Zlw?EPg_13zhS93Uc&P{FC2AVvqtsr zbyz|J^j6BK51jA1D*)eH&%88^2<*5D@H+@Fg8!$pc5yGnL9iELC9OEzhiS)TjjtdT z4X79c($G2%ly@Z9s_=~z+)umUJG%a#@PE<9zl@zR;XeHWtb=}2XJqN(NAsWW%nFk% ziiUHSm!&Fkr-C8Eoy?g@yD@1al6=-X9$A45LJ4$<@jj$pGZHL73mVO8oX`bmx#EIm zv)bTeGvBrM1UqbL@T5qr57?6F*8&YzSQG>#(t-yxRNS<*Vpr-{UzZ-?Px`%H8APio86PG2mnI6x-E%eXZoG{Z&>;jFUNK{Knb6vuo_>wy~cQey_Q8hir_!$CgXz zhBKF@6xz3R+o}MX5^>|`A?Dp$%i0?48c^rA1mj#`F)b?1K4$?0eA_`aWHT=eF`HGv zyw9o@?45ch*>78eZYs-Y5-=i&ukn;5u+_gXud)Q|=soqTN|v&1d_y8AN~K_3vIttI z>t;Pt4$R#QK$*ir=3AUv#2g1#-6?)g@wdPH01W4$SZbk=uX1dxT1C123Jc?xqV!ME zeO|TwOYvgx5+9~MWi_?Z`dm%PoxM+K(Aq2d^i-f;-7Tzh3mGKkUZ?eR$;(F2fT#+5 z0HK#fqP>^r^6{~Bi}P~-(ykvX2H^aT%>v4fg%0i26K^@tVP|b-M>t0>slL7W`4C;@@ftkZy@z=w9`PV~e9mp?{4}bUa zr_X;l8~8wu8$Zqc@BL$|@VIOkVDx8U8it9l%;hA5;!;3Tq5Mxrw8`YNi0Gf$U%srE zrC_KGbBlA$;FV88T{4rvFw5XhxCUj{;d(khSVVOqLvsNy+3IY|5ZEjJ#Wz+*|KUnH zt0=}0S-QCJCIxwk1KgjHPLs0dMKXd6)a+UjaBD2?rLlmw#p$jRQ+Vgq8#Eoy+18l|`1nWF2VDxm5Q!Erj z1_a}yEz@%usZ-_jtvH{S6IP)6^g=IH+z0OD#C^g8Cx!14jC^YlaAyI27F%S>#JgAM mkIM}tsR617fZ#Ll8^H30%{6q_;r=i3_^(BB7c2OjyAuGBHLwf- literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/CcUbQ_Wl.js.gz b/apps/dashboard/build/_app/immutable/chunks/CcUbQ_Wl.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..335394934510d4f65e60bce2910d2f2d821ffa16 GIT binary patch literal 407 zcmV;I0cidoiwFP!000026IGJIZo)7OhVOd{)LnaMMGIkwLz@z@!zM(v-Luqe)o4;B z85=^p`<#Z-a*F&pzvKM2P}0~5tj>Eb>{IX4yLAc{0rrZc#LHX-Vo2|XB1g^!`7W7`}rW28vP=-wu0PPO;paG4hs%iW7 zX_BX`2*Qn0-|wKSTG$;3r7PcSx>!d!%F&*tv|M{pKco)hmp@&T$nzx0Zv5_*h$IYW zKym)+P@|_fh@oCTDe>diqJC#KXsG?b)fhJGvV=c(|I8-bOx7W|{const n=/^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(r);if(n)return a.push({name:n[1],matcher:n[2],optional:!1,rest:!0,chained:!0}),"(?:/([^]*))?";const o=/^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(r);if(o)return a.push({name:o[1],matcher:o[2],optional:!0,rest:!1,chained:!0}),"(?:/([^/]+))?";if(!r)return;const s=r.split(/\[(.+?)\](?!\])/);return"/"+s.map((c,l)=>{if(l%2){if(c.startsWith("x+"))return ct(String.fromCharCode(parseInt(c.slice(2),16)));if(c.startsWith("u+"))return ct(String.fromCharCode(...c.slice(2).split("-").map(_=>parseInt(_,16))));const h=ue.exec(c),[,u,w,f,d]=h;return a.push({name:f,matcher:d,optional:!!u,rest:!!w,chained:w?l===1&&s[0]==="":!1}),w?"([^]*?)":u?"([^/]*)?":"([^/]+?)"}return ct(c)}).join("")}).join("")}/?$`),params:a}}function de(t){return t!==""&&!/^\([^)]+\)$/.test(t)}function pe(t){return t.slice(1).split("/").filter(de)}function ge(t,a,e){const r={},n=t.slice(1),o=n.filter(i=>i!==void 0);let s=0;for(let i=0;ih).join("/"),s=0),l===void 0)if(c.rest)l="";else continue;if(!c.matcher||e[c.matcher](l)){r[c.name]=l;const h=a[i+1],u=n[i+1];h&&!h.rest&&h.optional&&u&&c.chained&&(s=0),!h&&!u&&Object.keys(r).length===o.length&&(s=0);continue}if(c.optional&&c.chained){s++;continue}return}if(!s)return r}function ct(t){return t.normalize().replace(/[[\]]/g,"\\$&").replace(/%/g,"%25").replace(/\//g,"%2[Ff]").replace(/\?/g,"%3[Ff]").replace(/#/g,"%23").replace(/[.*+?^${}()|\\]/g,"\\$&")}function me({nodes:t,server_loads:a,dictionary:e,matchers:r}){const n=new Set(a);return Object.entries(e).map(([i,[c,l,h]])=>{const{pattern:u,params:w}=he(i),f={id:i,exec:d=>{const _=u.exec(d);if(_)return ge(_,w,r)},errors:[1,...h||[]].map(d=>t[d]),layouts:[0,...l||[]].map(s),leaf:o(c)};return f.errors.length=f.layouts.length=Math.max(f.errors.length,f.layouts.length),f});function o(i){const c=i<0;return c&&(i=~i),[c,t[i]]}function s(i){return i===void 0?i:[n.has(i),t[i]]}}function Ft(t,a=JSON.parse){try{return a(sessionStorage[t])}catch{}}function It(t,a,e=JSON.stringify){const r=e(a);try{sessionStorage[t]=r}catch{}}function _e(t){return t.filter(a=>a!=null)}function Et(t){return t instanceof wt||t instanceof yt?t.status:500}function we(t){return t instanceof yt?t.text:"Internal Error"}const ve=new Set(["icon","shortcut icon","apple-touch-icon"]),I=Ft(Kt)??{},M=Ft(Dt)??{},P={url:Pt({}),page:Pt({}),navigating:ae(null),updated:ne()};function bt(t){I[t]=j()}function ye(t,a){let e=t+1;for(;I[e];)delete I[e],e+=1;for(e=a+1;M[e];)delete M[e],e+=1}function V(t,a=!1){return a?location.replace(t.href):location.href=t.href,new Promise(()=>{})}async function Bt(){if("serviceWorker"in navigator){const t=await navigator.serviceWorker.getRegistration(L||"/");t&&await t.update()}}function Tt(){}let kt,ht,Q,U,dt,b;const Z=[],tt=[];let v=null;function pt(){var t;(t=v==null?void 0:v.fork)==null||t.then(a=>a==null?void 0:a.discard()),v=null}const G=new Map,Mt=new Set,Ee=new Set,F=new Set;let m={branch:[],error:null,url:null},Vt=!1,et=!1,Ot=!0,H=!1,K=!1,Ht=!1,St=!1,Yt,E,R,O;const at=new Set,jt=new Map;async function Fe(t,a,e){var o,s,i,c,l;(o=globalThis.__sveltekit_1qjqcdh)!=null&&o.data&&globalThis.__sveltekit_1qjqcdh.data,document.URL!==location.href&&(location.href=location.href),b=t,await((i=(s=t.hooks).init)==null?void 0:i.call(s)),kt=me(t),U=document.documentElement,dt=a,ht=t.nodes[0],Q=t.nodes[1],ht(),Q(),E=(c=history.state)==null?void 0:c[N],R=(l=history.state)==null?void 0:l[B],E||(E=R=Date.now(),history.replaceState({...history.state,[N]:E,[B]:R},""));const r=I[E];function n(){r&&(history.scrollRestoration="manual",scrollTo(r.x,r.y))}e?(n(),await je(dt,e)):(await q({type:"enter",url:mt(b.hash?Ne(new URL(location.href)):location.href),replace_state:!0}),n()),Oe()}function be(){Z.length=0,St=!1}function zt(t){tt.some(a=>a==null?void 0:a.snapshot)&&(M[t]=tt.map(a=>{var e;return(e=a==null?void 0:a.snapshot)==null?void 0:e.capture()}))}function Wt(t){var a;(a=M[t])==null||a.forEach((e,r)=>{var n,o;(o=(n=tt[r])==null?void 0:n.snapshot)==null||o.restore(e)})}function Ct(){bt(E),It(Kt,I),zt(R),It(Dt,M)}async function Gt(t,a,e,r){let n;a.invalidateAll&&pt(),await q({type:"goto",url:mt(t),keepfocus:a.keepFocus,noscroll:a.noScroll,replace_state:a.replaceState,state:a.state,redirect_count:e,nav_token:r,accept:()=>{a.invalidateAll&&(St=!0,n=[...jt.keys()]),a.invalidate&&a.invalidate.forEach(Te)}}),a.invalidateAll&&J().then(J).then(()=>{jt.forEach(({resource:o},s)=>{var i;n!=null&&n.includes(s)&&((i=o.refresh)==null||i.call(o))})})}async function ke(t){if(t.id!==(v==null?void 0:v.id)){pt();const a={};at.add(a),v={id:t.id,token:a,promise:Xt({...t,preload:a}).then(e=>(at.delete(a),e.type==="loaded"&&e.state.error&&pt(),e)),fork:null}}return v.promise}async function lt(t){var e;const a=(e=await ot(t,!1))==null?void 0:e.route;a&&await Promise.all([...a.layouts,a.leaf].filter(Boolean).map(r=>r[1]()))}async function Jt(t,a,e){var n;m=t.state;const r=document.querySelector("style[data-sveltekit]");if(r&&r.remove(),Object.assign(x,t.props.page),Yt=new b.root({target:a,props:{...t.props,stores:P,components:tt},hydrate:e,sync:!1}),await Promise.resolve(),Wt(R),e){const o={from:null,to:{params:m.params,route:{id:((n=m.route)==null?void 0:n.id)??null},url:new URL(location.href),scroll:I[E]??j()},willUnload:!1,type:"enter",complete:Promise.resolve()};F.forEach(s=>s(o))}et=!0}function nt({url:t,params:a,branch:e,status:r,error:n,route:o,form:s}){let i="never";if(L&&(t.pathname===L||t.pathname===L+"/"))i="always";else for(const f of e)(f==null?void 0:f.slash)!==void 0&&(i=f.slash);t.pathname=se(t.pathname,i),t.search=t.search;const c={type:"loaded",state:{url:t,params:a,branch:e,error:n,route:o},props:{constructors:_e(e).map(f=>f.node.component),page:At(x)}};s!==void 0&&(c.props.form=s);let l={},h=!x,u=0;for(let f=0;fi(new URL(s))))return!0;return!1}function xt(t,a){return(t==null?void 0:t.type)==="data"?t:(t==null?void 0:t.type)==="skip"?a??null:null}function xe(t,a){if(!t)return new Set(a.searchParams.keys());const e=new Set([...t.searchParams.keys(),...a.searchParams.keys()]);for(const r of e){const n=t.searchParams.getAll(r),o=a.searchParams.getAll(r);n.every(s=>o.includes(s))&&o.every(s=>n.includes(s))&&e.delete(r)}return e}function Le({error:t,url:a,route:e,params:r}){return{type:"loaded",state:{error:t,url:a,route:e,params:r,branch:[]},props:{page:At(x),constructors:[]}}}async function Xt({id:t,invalidating:a,url:e,params:r,route:n,preload:o}){if((v==null?void 0:v.id)===t)return at.delete(v.token),v.promise;const{errors:s,layouts:i,leaf:c}=n,l=[...i,c];s.forEach(g=>g==null?void 0:g().catch(()=>{})),l.forEach(g=>g==null?void 0:g[1]().catch(()=>{}));const h=m.url?t!==rt(m.url):!1,u=m.route?n.id!==m.route.id:!1,w=xe(m.url,e);let f=!1;const d=l.map(async(g,p)=>{var A;if(!g)return;const y=m.branch[p];return g[1]===(y==null?void 0:y.loader)&&!Re(f,u,h,w,(A=y.universal)==null?void 0:A.uses,r)?y:(f=!0,Rt({loader:g[1],url:e,params:r,route:n,parent:async()=>{var z;const T={};for(let C=0;C{});const _=[];for(let g=0;gPromise.resolve({}),server_data_node:xt(o)}),i={node:await Q(),loader:Q,universal:null,server:null,data:null};return nt({url:e,params:n,branch:[s,i],status:t,error:a,route:null})}catch(s){if(s instanceof vt)return Gt(new URL(s.location,location.href),{},0);throw s}}async function Ae(t){const a=t.href;if(G.has(a))return G.get(a);let e;try{const r=(async()=>{let n=await b.hooks.reroute({url:new URL(t),fetch:async(o,s)=>Se(o,s,t).promise})??t;if(typeof n=="string"){const o=new URL(t);b.hash?o.hash=n:o.pathname=n,n=o}return n})();G.set(a,r),e=await r}catch{G.delete(a);return}return e}async function ot(t,a){if(t&&!_t(t,L,b.hash)){const e=await Ae(t);if(!e)return;const r=Pe(e);for(const n of kt){const o=n.exec(r);if(o)return{id:rt(t),invalidating:a,route:n,params:oe(o),url:t}}}}function Pe(t){return ie(b.hash?t.hash.replace(/^#/,"").replace(/[?#].+/,""):t.pathname.slice(L.length))||"/"}function rt(t){return(b.hash?t.hash.replace(/^#/,""):t.pathname)+t.search}function Qt({url:t,type:a,intent:e,delta:r,event:n,scroll:o}){let s=!1;const i=Ut(m,e,t,a,o??null);r!==void 0&&(i.navigation.delta=r),n!==void 0&&(i.navigation.event=n);const c={...i.navigation,cancel:()=>{s=!0,i.reject(new Error("navigation cancelled"))}};return H||Mt.forEach(l=>l(c)),s?null:i}async function q({type:t,url:a,popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s={},redirect_count:i=0,nav_token:c={},accept:l=Tt,block:h=Tt,event:u}){var C;const w=O;O=c;const f=await ot(a,!1),d=t==="enter"?Ut(m,f,a,t):Qt({url:a,type:t,delta:e==null?void 0:e.delta,intent:f,scroll:e==null?void 0:e.scroll,event:u});if(!d){h(),O===c&&(O=w);return}const _=E,g=R;l(),H=!0,et&&d.navigation.type!=="enter"&&P.navigating.set(ft.current=d.navigation);let p=f&&await Xt(f);if(!p){if(_t(a,L,b.hash))return await V(a,o);p=await Zt(a,{id:null},await Y(new yt(404,"Not Found",`Not found: ${a.pathname}`),{url:a,params:{},route:{id:null}}),404,o)}if(a=(f==null?void 0:f.url)||a,O!==c)return d.reject(new Error("navigation aborted")),!1;if(p.type==="redirect"){if(i<20){await q({type:t,url:new URL(p.location,a),popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s,redirect_count:i+1,nav_token:c}),d.fulfil(void 0);return}p=await Lt({status:500,error:await Y(new Error("Redirect loop"),{url:a,params:{},route:{id:null}}),url:a,route:{id:null}})}else p.props.page.status>=400&&await P.updated.check()&&(await Bt(),await V(a,o));if(be(),bt(_),zt(g),p.props.page.url.pathname!==a.pathname&&(a.pathname=p.props.page.url.pathname),s=e?e.state:s,!e){const k=o?0:1,W={[N]:E+=k,[B]:R+=k,[Nt]:s};(o?history.replaceState:history.pushState).call(history,W,"",a),o||ye(E,R)}const y=f&&(v==null?void 0:v.id)===f.id?v.fork:null;v=null,p.props.page.state=s;let S;if(et){const k=(await Promise.all(Array.from(Ee,$=>$(d.navigation)))).filter($=>typeof $=="function");if(k.length>0){let $=function(){k.forEach(st=>{F.delete(st)})};k.push($),k.forEach(st=>{F.add(st)})}m=p.state,p.props.page&&(p.props.page.url=a);const W=y&&await y;W?S=W.commit():(Yt.$set(p.props),fe(p.props.page),S=(C=ee)==null?void 0:C()),Ht=!0}else await Jt(p,dt,!1);const{activeElement:A}=document;await S,await J(),await J();let T=null;if(Ot){const k=e?e.scroll:n?j():null;k?scrollTo(k.x,k.y):(T=a.hash&&document.getElementById(te(a)))?T.scrollIntoView():scrollTo(0,0)}const z=document.activeElement!==A&&document.activeElement!==document.body;!r&&!z&&$e(a,!T),Ot=!0,p.props.page&&Object.assign(x,p.props.page),H=!1,t==="popstate"&&Wt(R),d.fulfil(void 0),d.navigation.to&&(d.navigation.to.scroll=j()),F.forEach(k=>k(d.navigation)),P.navigating.set(ft.current=null)}async function Zt(t,a,e,r,n){return t.origin===qt&&t.pathname===location.pathname&&!Vt?await Lt({status:r,error:e,url:t,route:a}):await V(t,n)}function Ie(){let t,a={element:void 0,href:void 0},e;U.addEventListener("mousemove",i=>{const c=i.target;clearTimeout(t),t=setTimeout(()=>{o(c,D.hover)},20)});function r(i){i.defaultPrevented||o(i.composedPath()[0],D.tap)}U.addEventListener("mousedown",r),U.addEventListener("touchstart",r,{passive:!0});const n=new IntersectionObserver(i=>{for(const c of i)c.isIntersecting&&(lt(new URL(c.target.href)),n.unobserve(c.target))},{threshold:0});async function o(i,c){const l=$t(i,U),h=l===a.element&&(l==null?void 0:l.href)===a.href&&c>=e;if(!l||h)return;const{url:u,external:w,download:f}=ut(l,L,b.hash);if(w||f)return;const d=X(l),_=u&&rt(m.url)===rt(u);if(!(d.reload||_))if(c<=d.preload_data){a={element:l,href:l.href},e=D.tap;const g=await ot(u,!1);if(!g)return;ke(g)}else c<=d.preload_code&&(a={element:l,href:l.href},e=c,lt(u))}function s(){n.disconnect();for(const i of U.querySelectorAll("a")){const{url:c,external:l,download:h}=ut(i,L,b.hash);if(l||h)continue;const u=X(i);u.reload||(u.preload_code===D.viewport&&n.observe(i),u.preload_code===D.eager&<(c))}}F.add(s),s()}function Y(t,a){if(t instanceof wt)return t.body;const e=Et(t),r=we(t);return b.hooks.handleError({error:t,event:a,status:e,message:r})??{message:r}}function Be(t,a={}){return t=new URL(mt(t)),t.origin!==qt?Promise.reject(new Error("goto: invalid URL")):Gt(t,a,0)}function Te(t){if(typeof t=="function")Z.push(t);else{const{href:a}=new URL(t,location.href);Z.push(e=>e.href===a)}}function Oe(){var a;history.scrollRestoration="manual",addEventListener("beforeunload",e=>{let r=!1;if(Ct(),!H){const n=Ut(m,void 0,null,"leave"),o={...n.navigation,cancel:()=>{r=!0,n.reject(new Error("navigation cancelled"))}};Mt.forEach(s=>s(o))}r?(e.preventDefault(),e.returnValue=""):history.scrollRestoration="auto"}),addEventListener("visibilitychange",()=>{document.visibilityState==="hidden"&&Ct()}),(a=navigator.connection)!=null&&a.saveData||Ie(),U.addEventListener("click",async e=>{if(e.button||e.which!==1||e.metaKey||e.ctrlKey||e.shiftKey||e.altKey||e.defaultPrevented)return;const r=$t(e.composedPath()[0],U);if(!r)return;const{url:n,external:o,target:s,download:i}=ut(r,L,b.hash);if(!n)return;if(s==="_parent"||s==="_top"){if(window.parent!==window)return}else if(s&&s!=="_self")return;const c=X(r);if(!(r instanceof SVGAElement)&&n.protocol!==location.protocol&&!(n.protocol==="https:"||n.protocol==="http:")||i)return;const[h,u]=(b.hash?n.hash.replace(/^#/,""):n.href).split("#"),w=h===it(location);if(o||c.reload&&(!w||!u)){Qt({url:n,type:"link",event:e})?H=!0:e.preventDefault();return}if(u!==void 0&&w){const[,f]=m.url.href.split("#");if(f===u){if(e.preventDefault(),u===""||u==="top"&&r.ownerDocument.getElementById("top")===null)scrollTo({top:0});else{const d=r.ownerDocument.getElementById(decodeURIComponent(u));d&&(d.scrollIntoView(),d.focus())}return}if(K=!0,bt(E),t(n),!c.replace_state)return;K=!1}e.preventDefault(),await new Promise(f=>{requestAnimationFrame(()=>{setTimeout(f,0)}),setTimeout(f,100)}),await q({type:"link",url:n,keepfocus:c.keepfocus,noscroll:c.noscroll,replace_state:c.replace_state??n.href===location.href,event:e})}),U.addEventListener("submit",e=>{if(e.defaultPrevented)return;const r=HTMLFormElement.prototype.cloneNode.call(e.target),n=e.submitter;if(((n==null?void 0:n.formTarget)||r.target)==="_blank"||((n==null?void 0:n.formMethod)||r.method)!=="get")return;const i=new URL((n==null?void 0:n.hasAttribute("formaction"))&&(n==null?void 0:n.formAction)||r.action);if(_t(i,L,!1))return;const c=e.target,l=X(c);if(l.reload)return;e.preventDefault(),e.stopPropagation();const h=new FormData(c,n);i.search=new URLSearchParams(h).toString(),q({type:"form",url:i,keepfocus:l.keepfocus,noscroll:l.noscroll,replace_state:l.replace_state??i.href===location.href,event:e})}),addEventListener("popstate",async e=>{var r;if(!gt){if((r=e.state)!=null&&r[N]){const n=e.state[N];if(O={},n===E)return;const o=I[n],s=e.state[Nt]??{},i=new URL(e.state[re]??location.href),c=e.state[B],l=m.url?it(location)===it(m.url):!1;if(c===R&&(Ht||l)){s!==x.state&&(x.state=s),t(i),I[E]=j(),o&&scrollTo(o.x,o.y),E=n;return}const u=n-E;await q({type:"popstate",url:i,popped:{state:s,scroll:o,delta:u},accept:()=>{E=n,R=c},block:()=>{history.go(-u)},nav_token:O,event:e})}else if(!K){const n=new URL(location.href);t(n),b.hash&&location.reload()}}}),addEventListener("hashchange",()=>{K&&(K=!1,history.replaceState({...history.state,[N]:++E,[B]:R},"",location.href))});for(const e of document.querySelectorAll("link"))ve.has(e.rel)&&(e.href=e.href);addEventListener("pageshow",e=>{e.persisted&&P.navigating.set(ft.current=null)});function t(e){m.url=x.url=e,P.page.set(At(x)),P.page.notify()}}async function je(t,{status:a=200,error:e,node_ids:r,params:n,route:o,server_route:s,data:i,form:c}){Vt=!0;const l=new URL(location.href);let h;({params:n={},route:o={id:null}}=await ot(l,!1)||{}),h=kt.find(({id:f})=>f===o.id);let u,w=!0;try{const f=r.map(async(_,g)=>{const p=i[g];return p!=null&&p.uses&&(p.uses=Ce(p.uses)),Rt({loader:b.nodes[_],url:l,params:n,route:o,parent:async()=>{const y={};for(let S=0;S{const i=history.state;gt=!0,location.replace(new URL(`#${r}`,location.href)),history.replaceState(i,"",t),a&&scrollTo(o,s),gt=!1})}else{const o=document.body,s=o.getAttribute("tabindex");o.tabIndex=-1,o.focus({preventScroll:!0,focusVisible:!1}),s!==null?o.setAttribute("tabindex",s):o.removeAttribute("tabindex")}const n=getSelection();if(n&&n.type!=="None"){const o=[];for(let s=0;s{if(n.rangeCount===o.length){for(let s=0;s{o=u,s=w});return i.catch(()=>{}),{navigation:{from:{params:t.params,route:{id:((l=t.route)==null?void 0:l.id)??null},url:t.url,scroll:j()},to:e&&{params:(a==null?void 0:a.params)??null,route:{id:((h=a==null?void 0:a.route)==null?void 0:h.id)??null},url:e,scroll:n},willUnload:!a,type:r,complete:i},fulfil:o,reject:s}}function At(t){return{data:t.data,error:t.error,form:t.form,params:t.params,route:t.route,state:t.state,status:t.status,url:t.url}}function Ne(t){const a=new URL(t);return a.hash=decodeURIComponent(t.hash),a}function te(t){let a;if(b.hash){const[,,e]=t.hash.split("#",3);a=e??""}else a=t.hash.slice(1);return decodeURIComponent(a)}export{Fe as a,Be as g,P as s}; +import{$ as J,bd as ee}from"./CpWkWWOo.js";import{w as ae}from"./BeMFXnHE.js";import{c as ne,H as N,N as B,r as gt,i as _t,b as L,s as C,p as x,n as ft,f as $t,g as ut,a as X,d as it,S as Nt,P as re,e as oe,h as se,o as Dt,j as q,k as ie,l as qt,m as ce,q as le,t as Kt,u as Pt,v as fe}from"./DGcYlAAw.js";class wt{constructor(a,e){this.status=a,typeof e=="string"?this.body={message:e}:e?this.body=e:this.body={message:`Error: ${a}`}}toString(){return JSON.stringify(this.body)}}class vt{constructor(a,e){this.status=a,this.location=e}}class yt extends Error{constructor(a,e,r){super(r),this.status=a,this.text=e}}const ue=/^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;function he(t){const a=[];return{pattern:t==="/"?/^\/$/:new RegExp(`^${pe(t).map(r=>{const n=/^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(r);if(n)return a.push({name:n[1],matcher:n[2],optional:!1,rest:!0,chained:!0}),"(?:/([^]*))?";const o=/^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(r);if(o)return a.push({name:o[1],matcher:o[2],optional:!0,rest:!1,chained:!0}),"(?:/([^/]+))?";if(!r)return;const s=r.split(/\[(.+?)\](?!\])/);return"/"+s.map((c,l)=>{if(l%2){if(c.startsWith("x+"))return ct(String.fromCharCode(parseInt(c.slice(2),16)));if(c.startsWith("u+"))return ct(String.fromCharCode(...c.slice(2).split("-").map(_=>parseInt(_,16))));const h=ue.exec(c),[,u,w,f,d]=h;return a.push({name:f,matcher:d,optional:!!u,rest:!!w,chained:w?l===1&&s[0]==="":!1}),w?"([^]*?)":u?"([^/]*)?":"([^/]+?)"}return ct(c)}).join("")}).join("")}/?$`),params:a}}function de(t){return t!==""&&!/^\([^)]+\)$/.test(t)}function pe(t){return t.slice(1).split("/").filter(de)}function me(t,a,e){const r={},n=t.slice(1),o=n.filter(i=>i!==void 0);let s=0;for(let i=0;ih).join("/"),s=0),l===void 0)if(c.rest)l="";else continue;if(!c.matcher||e[c.matcher](l)){r[c.name]=l;const h=a[i+1],u=n[i+1];h&&!h.rest&&h.optional&&u&&c.chained&&(s=0),!h&&!u&&Object.keys(r).length===o.length&&(s=0);continue}if(c.optional&&c.chained){s++;continue}return}if(!s)return r}function ct(t){return t.normalize().replace(/[[\]]/g,"\\$&").replace(/%/g,"%25").replace(/\//g,"%2[Ff]").replace(/\?/g,"%3[Ff]").replace(/#/g,"%23").replace(/[.*+?^${}()|\\]/g,"\\$&")}function ge({nodes:t,server_loads:a,dictionary:e,matchers:r}){const n=new Set(a);return Object.entries(e).map(([i,[c,l,h]])=>{const{pattern:u,params:w}=he(i),f={id:i,exec:d=>{const _=u.exec(d);if(_)return me(_,w,r)},errors:[1,...h||[]].map(d=>t[d]),layouts:[0,...l||[]].map(s),leaf:o(c)};return f.errors.length=f.layouts.length=Math.max(f.errors.length,f.layouts.length),f});function o(i){const c=i<0;return c&&(i=~i),[c,t[i]]}function s(i){return i===void 0?i:[n.has(i),t[i]]}}function Ft(t,a=JSON.parse){try{return a(sessionStorage[t])}catch{}}function It(t,a,e=JSON.stringify){const r=e(a);try{sessionStorage[t]=r}catch{}}function _e(t){return t.filter(a=>a!=null)}function Et(t){return t instanceof wt||t instanceof yt?t.status:500}function we(t){return t instanceof yt?t.text:"Internal Error"}const ve=new Set(["icon","shortcut icon","apple-touch-icon"]),I=Ft(Kt)??{},M=Ft(qt)??{},P={url:Pt({}),page:Pt({}),navigating:ae(null),updated:ne()};function bt(t){I[t]=C()}function ye(t,a){let e=t+1;for(;I[e];)delete I[e],e+=1;for(e=a+1;M[e];)delete M[e],e+=1}function V(t,a=!1){return a?location.replace(t.href):location.href=t.href,new Promise(()=>{})}async function Bt(){if("serviceWorker"in navigator){const t=await navigator.serviceWorker.getRegistration(L||"/");t&&await t.update()}}function Tt(){}let kt,ht,Q,U,dt,b;const Z=[],tt=[];let v=null;function pt(){var t;(t=v==null?void 0:v.fork)==null||t.then(a=>a==null?void 0:a.discard()),v=null}const G=new Map,Mt=new Set,Ee=new Set,F=new Set;let g={branch:[],error:null,url:null},Vt=!1,et=!1,Ot=!0,H=!1,K=!1,Ht=!1,St=!1,Yt,E,R,O;const at=new Set,Ct=new Map;async function Fe(t,a,e){var o,s,i,c,l;(o=globalThis.__sveltekit_1r5nume)!=null&&o.data&&globalThis.__sveltekit_1r5nume.data,document.URL!==location.href&&(location.href=location.href),b=t,await((i=(s=t.hooks).init)==null?void 0:i.call(s)),kt=ge(t),U=document.documentElement,dt=a,ht=t.nodes[0],Q=t.nodes[1],ht(),Q(),E=(c=history.state)==null?void 0:c[N],R=(l=history.state)==null?void 0:l[B],E||(E=R=Date.now(),history.replaceState({...history.state,[N]:E,[B]:R},""));const r=I[E];function n(){r&&(history.scrollRestoration="manual",scrollTo(r.x,r.y))}e?(n(),await Ce(dt,e)):(await D({type:"enter",url:gt(b.hash?Ne(new URL(location.href)):location.href),replace_state:!0}),n()),Oe()}function be(){Z.length=0,St=!1}function zt(t){tt.some(a=>a==null?void 0:a.snapshot)&&(M[t]=tt.map(a=>{var e;return(e=a==null?void 0:a.snapshot)==null?void 0:e.capture()}))}function Wt(t){var a;(a=M[t])==null||a.forEach((e,r)=>{var n,o;(o=(n=tt[r])==null?void 0:n.snapshot)==null||o.restore(e)})}function jt(){bt(E),It(Kt,I),zt(R),It(qt,M)}async function Gt(t,a,e,r){let n;a.invalidateAll&&pt(),await D({type:"goto",url:gt(t),keepfocus:a.keepFocus,noscroll:a.noScroll,replace_state:a.replaceState,state:a.state,redirect_count:e,nav_token:r,accept:()=>{a.invalidateAll&&(St=!0,n=[...Ct.keys()]),a.invalidate&&a.invalidate.forEach(Te)}}),a.invalidateAll&&J().then(J).then(()=>{Ct.forEach(({resource:o},s)=>{var i;n!=null&&n.includes(s)&&((i=o.refresh)==null||i.call(o))})})}async function ke(t){if(t.id!==(v==null?void 0:v.id)){pt();const a={};at.add(a),v={id:t.id,token:a,promise:Xt({...t,preload:a}).then(e=>(at.delete(a),e.type==="loaded"&&e.state.error&&pt(),e)),fork:null}}return v.promise}async function lt(t){var e;const a=(e=await ot(t,!1))==null?void 0:e.route;a&&await Promise.all([...a.layouts,a.leaf].filter(Boolean).map(r=>r[1]()))}async function Jt(t,a,e){var n;g=t.state;const r=document.querySelector("style[data-sveltekit]");if(r&&r.remove(),Object.assign(x,t.props.page),Yt=new b.root({target:a,props:{...t.props,stores:P,components:tt},hydrate:e,sync:!1}),await Promise.resolve(),Wt(R),e){const o={from:null,to:{params:g.params,route:{id:((n=g.route)==null?void 0:n.id)??null},url:new URL(location.href),scroll:I[E]??C()},willUnload:!1,type:"enter",complete:Promise.resolve()};F.forEach(s=>s(o))}et=!0}function nt({url:t,params:a,branch:e,status:r,error:n,route:o,form:s}){let i="never";if(L&&(t.pathname===L||t.pathname===L+"/"))i="always";else for(const f of e)(f==null?void 0:f.slash)!==void 0&&(i=f.slash);t.pathname=se(t.pathname,i),t.search=t.search;const c={type:"loaded",state:{url:t,params:a,branch:e,error:n,route:o},props:{constructors:_e(e).map(f=>f.node.component),page:At(x)}};s!==void 0&&(c.props.form=s);let l={},h=!x,u=0;for(let f=0;fi(new URL(s))))return!0;return!1}function xt(t,a){return(t==null?void 0:t.type)==="data"?t:(t==null?void 0:t.type)==="skip"?a??null:null}function xe(t,a){if(!t)return new Set(a.searchParams.keys());const e=new Set([...t.searchParams.keys(),...a.searchParams.keys()]);for(const r of e){const n=t.searchParams.getAll(r),o=a.searchParams.getAll(r);n.every(s=>o.includes(s))&&o.every(s=>n.includes(s))&&e.delete(r)}return e}function Le({error:t,url:a,route:e,params:r}){return{type:"loaded",state:{error:t,url:a,route:e,params:r,branch:[]},props:{page:At(x),constructors:[]}}}async function Xt({id:t,invalidating:a,url:e,params:r,route:n,preload:o}){if((v==null?void 0:v.id)===t)return at.delete(v.token),v.promise;const{errors:s,layouts:i,leaf:c}=n,l=[...i,c];s.forEach(m=>m==null?void 0:m().catch(()=>{})),l.forEach(m=>m==null?void 0:m[1]().catch(()=>{}));const h=g.url?t!==rt(g.url):!1,u=g.route?n.id!==g.route.id:!1,w=xe(g.url,e);let f=!1;const d=l.map(async(m,p)=>{var A;if(!m)return;const y=g.branch[p];return m[1]===(y==null?void 0:y.loader)&&!Re(f,u,h,w,(A=y.universal)==null?void 0:A.uses,r)?y:(f=!0,Rt({loader:m[1],url:e,params:r,route:n,parent:async()=>{var z;const T={};for(let j=0;j{});const _=[];for(let m=0;mPromise.resolve({}),server_data_node:xt(o)}),i={node:await Q(),loader:Q,universal:null,server:null,data:null};return nt({url:e,params:n,branch:[s,i],status:t,error:a,route:null})}catch(s){if(s instanceof vt)return Gt(new URL(s.location,location.href),{},0);throw s}}async function Ae(t){const a=t.href;if(G.has(a))return G.get(a);let e;try{const r=(async()=>{let n=await b.hooks.reroute({url:new URL(t),fetch:async(o,s)=>Se(o,s,t).promise})??t;if(typeof n=="string"){const o=new URL(t);b.hash?o.hash=n:o.pathname=n,n=o}return n})();G.set(a,r),e=await r}catch{G.delete(a);return}return e}async function ot(t,a){if(t&&!_t(t,L,b.hash)){const e=await Ae(t);if(!e)return;const r=Pe(e);for(const n of kt){const o=n.exec(r);if(o)return{id:rt(t),invalidating:a,route:n,params:oe(o),url:t}}}}function Pe(t){return ie(b.hash?t.hash.replace(/^#/,"").replace(/[?#].+/,""):t.pathname.slice(L.length))||"/"}function rt(t){return(b.hash?t.hash.replace(/^#/,""):t.pathname)+t.search}function Qt({url:t,type:a,intent:e,delta:r,event:n,scroll:o}){let s=!1;const i=Ut(g,e,t,a,o??null);r!==void 0&&(i.navigation.delta=r),n!==void 0&&(i.navigation.event=n);const c={...i.navigation,cancel:()=>{s=!0,i.reject(new Error("navigation cancelled"))}};return H||Mt.forEach(l=>l(c)),s?null:i}async function D({type:t,url:a,popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s={},redirect_count:i=0,nav_token:c={},accept:l=Tt,block:h=Tt,event:u}){var j;const w=O;O=c;const f=await ot(a,!1),d=t==="enter"?Ut(g,f,a,t):Qt({url:a,type:t,delta:e==null?void 0:e.delta,intent:f,scroll:e==null?void 0:e.scroll,event:u});if(!d){h(),O===c&&(O=w);return}const _=E,m=R;l(),H=!0,et&&d.navigation.type!=="enter"&&P.navigating.set(ft.current=d.navigation);let p=f&&await Xt(f);if(!p){if(_t(a,L,b.hash))return await V(a,o);p=await Zt(a,{id:null},await Y(new yt(404,"Not Found",`Not found: ${a.pathname}`),{url:a,params:{},route:{id:null}}),404,o)}if(a=(f==null?void 0:f.url)||a,O!==c)return d.reject(new Error("navigation aborted")),!1;if(p.type==="redirect"){if(i<20){await D({type:t,url:new URL(p.location,a),popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s,redirect_count:i+1,nav_token:c}),d.fulfil(void 0);return}p=await Lt({status:500,error:await Y(new Error("Redirect loop"),{url:a,params:{},route:{id:null}}),url:a,route:{id:null}})}else p.props.page.status>=400&&await P.updated.check()&&(await Bt(),await V(a,o));if(be(),bt(_),zt(m),p.props.page.url.pathname!==a.pathname&&(a.pathname=p.props.page.url.pathname),s=e?e.state:s,!e){const k=o?0:1,W={[N]:E+=k,[B]:R+=k,[Nt]:s};(o?history.replaceState:history.pushState).call(history,W,"",a),o||ye(E,R)}const y=f&&(v==null?void 0:v.id)===f.id?v.fork:null;v=null,p.props.page.state=s;let S;if(et){const k=(await Promise.all(Array.from(Ee,$=>$(d.navigation)))).filter($=>typeof $=="function");if(k.length>0){let $=function(){k.forEach(st=>{F.delete(st)})};k.push($),k.forEach(st=>{F.add(st)})}g=p.state,p.props.page&&(p.props.page.url=a);const W=y&&await y;W?S=W.commit():(Yt.$set(p.props),fe(p.props.page),S=(j=ee)==null?void 0:j()),Ht=!0}else await Jt(p,dt,!1);const{activeElement:A}=document;await S,await J(),await J();let T=null;if(Ot){const k=e?e.scroll:n?C():null;k?scrollTo(k.x,k.y):(T=a.hash&&document.getElementById(te(a)))?T.scrollIntoView():scrollTo(0,0)}const z=document.activeElement!==A&&document.activeElement!==document.body;!r&&!z&&$e(a,!T),Ot=!0,p.props.page&&Object.assign(x,p.props.page),H=!1,t==="popstate"&&Wt(R),d.fulfil(void 0),d.navigation.to&&(d.navigation.to.scroll=C()),F.forEach(k=>k(d.navigation)),P.navigating.set(ft.current=null)}async function Zt(t,a,e,r,n){return t.origin===Dt&&t.pathname===location.pathname&&!Vt?await Lt({status:r,error:e,url:t,route:a}):await V(t,n)}function Ie(){let t,a={element:void 0,href:void 0},e;U.addEventListener("mousemove",i=>{const c=i.target;clearTimeout(t),t=setTimeout(()=>{o(c,q.hover)},20)});function r(i){i.defaultPrevented||o(i.composedPath()[0],q.tap)}U.addEventListener("mousedown",r),U.addEventListener("touchstart",r,{passive:!0});const n=new IntersectionObserver(i=>{for(const c of i)c.isIntersecting&&(lt(new URL(c.target.href)),n.unobserve(c.target))},{threshold:0});async function o(i,c){const l=$t(i,U),h=l===a.element&&(l==null?void 0:l.href)===a.href&&c>=e;if(!l||h)return;const{url:u,external:w,download:f}=ut(l,L,b.hash);if(w||f)return;const d=X(l),_=u&&rt(g.url)===rt(u);if(!(d.reload||_))if(c<=d.preload_data){a={element:l,href:l.href},e=q.tap;const m=await ot(u,!1);if(!m)return;ke(m)}else c<=d.preload_code&&(a={element:l,href:l.href},e=c,lt(u))}function s(){n.disconnect();for(const i of U.querySelectorAll("a")){const{url:c,external:l,download:h}=ut(i,L,b.hash);if(l||h)continue;const u=X(i);u.reload||(u.preload_code===q.viewport&&n.observe(i),u.preload_code===q.eager&<(c))}}F.add(s),s()}function Y(t,a){if(t instanceof wt)return t.body;const e=Et(t),r=we(t);return b.hooks.handleError({error:t,event:a,status:e,message:r})??{message:r}}function Be(t,a={}){return t=new URL(gt(t)),t.origin!==Dt?Promise.reject(new Error("goto: invalid URL")):Gt(t,a,0)}function Te(t){if(typeof t=="function")Z.push(t);else{const{href:a}=new URL(t,location.href);Z.push(e=>e.href===a)}}function Oe(){var a;history.scrollRestoration="manual",addEventListener("beforeunload",e=>{let r=!1;if(jt(),!H){const n=Ut(g,void 0,null,"leave"),o={...n.navigation,cancel:()=>{r=!0,n.reject(new Error("navigation cancelled"))}};Mt.forEach(s=>s(o))}r?(e.preventDefault(),e.returnValue=""):history.scrollRestoration="auto"}),addEventListener("visibilitychange",()=>{document.visibilityState==="hidden"&&jt()}),(a=navigator.connection)!=null&&a.saveData||Ie(),U.addEventListener("click",async e=>{if(e.button||e.which!==1||e.metaKey||e.ctrlKey||e.shiftKey||e.altKey||e.defaultPrevented)return;const r=$t(e.composedPath()[0],U);if(!r)return;const{url:n,external:o,target:s,download:i}=ut(r,L,b.hash);if(!n)return;if(s==="_parent"||s==="_top"){if(window.parent!==window)return}else if(s&&s!=="_self")return;const c=X(r);if(!(r instanceof SVGAElement)&&n.protocol!==location.protocol&&!(n.protocol==="https:"||n.protocol==="http:")||i)return;const[h,u]=(b.hash?n.hash.replace(/^#/,""):n.href).split("#"),w=h===it(location);if(o||c.reload&&(!w||!u)){Qt({url:n,type:"link",event:e})?H=!0:e.preventDefault();return}if(u!==void 0&&w){const[,f]=g.url.href.split("#");if(f===u){if(e.preventDefault(),u===""||u==="top"&&r.ownerDocument.getElementById("top")===null)scrollTo({top:0});else{const d=r.ownerDocument.getElementById(decodeURIComponent(u));d&&(d.scrollIntoView(),d.focus())}return}if(K=!0,bt(E),t(n),!c.replace_state)return;K=!1}e.preventDefault(),await new Promise(f=>{requestAnimationFrame(()=>{setTimeout(f,0)}),setTimeout(f,100)}),await D({type:"link",url:n,keepfocus:c.keepfocus,noscroll:c.noscroll,replace_state:c.replace_state??n.href===location.href,event:e})}),U.addEventListener("submit",e=>{if(e.defaultPrevented)return;const r=HTMLFormElement.prototype.cloneNode.call(e.target),n=e.submitter;if(((n==null?void 0:n.formTarget)||r.target)==="_blank"||((n==null?void 0:n.formMethod)||r.method)!=="get")return;const i=new URL((n==null?void 0:n.hasAttribute("formaction"))&&(n==null?void 0:n.formAction)||r.action);if(_t(i,L,!1))return;const c=e.target,l=X(c);if(l.reload)return;e.preventDefault(),e.stopPropagation();const h=new FormData(c,n);i.search=new URLSearchParams(h).toString(),D({type:"form",url:i,keepfocus:l.keepfocus,noscroll:l.noscroll,replace_state:l.replace_state??i.href===location.href,event:e})}),addEventListener("popstate",async e=>{var r;if(!mt){if((r=e.state)!=null&&r[N]){const n=e.state[N];if(O={},n===E)return;const o=I[n],s=e.state[Nt]??{},i=new URL(e.state[re]??location.href),c=e.state[B],l=g.url?it(location)===it(g.url):!1;if(c===R&&(Ht||l)){s!==x.state&&(x.state=s),t(i),I[E]=C(),o&&scrollTo(o.x,o.y),E=n;return}const u=n-E;await D({type:"popstate",url:i,popped:{state:s,scroll:o,delta:u},accept:()=>{E=n,R=c},block:()=>{history.go(-u)},nav_token:O,event:e})}else if(!K){const n=new URL(location.href);t(n),b.hash&&location.reload()}}}),addEventListener("hashchange",()=>{K&&(K=!1,history.replaceState({...history.state,[N]:++E,[B]:R},"",location.href))});for(const e of document.querySelectorAll("link"))ve.has(e.rel)&&(e.href=e.href);addEventListener("pageshow",e=>{e.persisted&&P.navigating.set(ft.current=null)});function t(e){g.url=x.url=e,P.page.set(At(x)),P.page.notify()}}async function Ce(t,{status:a=200,error:e,node_ids:r,params:n,route:o,server_route:s,data:i,form:c}){Vt=!0;const l=new URL(location.href);let h;({params:n={},route:o={id:null}}=await ot(l,!1)||{}),h=kt.find(({id:f})=>f===o.id);let u,w=!0;try{const f=r.map(async(_,m)=>{const p=i[m];return p!=null&&p.uses&&(p.uses=je(p.uses)),Rt({loader:b.nodes[_],url:l,params:n,route:o,parent:async()=>{const y={};for(let S=0;S{const i=history.state;mt=!0,location.replace(new URL(`#${r}`,location.href)),history.replaceState(i,"",t),a&&scrollTo(o,s),mt=!1})}else{const o=document.body,s=o.getAttribute("tabindex");o.tabIndex=-1,o.focus({preventScroll:!0,focusVisible:!1}),s!==null?o.setAttribute("tabindex",s):o.removeAttribute("tabindex")}const n=getSelection();if(n&&n.type!=="None"){const o=[];for(let s=0;s{if(n.rangeCount===o.length){for(let s=0;s{o=u,s=w});return i.catch(()=>{}),{navigation:{from:{params:t.params,route:{id:((l=t.route)==null?void 0:l.id)??null},url:t.url,scroll:C()},to:e&&{params:(a==null?void 0:a.params)??null,route:{id:((h=a==null?void 0:a.route)==null?void 0:h.id)??null},url:e,scroll:n},willUnload:!a,type:r,complete:i},fulfil:o,reject:s}}function At(t){return{data:t.data,error:t.error,form:t.form,params:t.params,route:t.route,state:t.state,status:t.status,url:t.url}}function Ne(t){const a=new URL(t);return a.hash=decodeURIComponent(t.hash),a}function te(t){let a;if(b.hash){const[,,e]=t.hash.split("#",3);a=e??""}else a=t.hash.slice(1);return decodeURIComponent(a)}export{Fe as a,Be as g,P as s}; diff --git a/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.br b/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.br new file mode 100644 index 0000000000000000000000000000000000000000..64ff75497e0b12ba79d1489131493d32119fb630 GIT binary patch literal 7644 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 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.gz b/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..466d96047fdc64515d8e0aa85610b450aaec9c36 GIT binary patch literal 8427 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 N^}q3IMTp^3005-EQYQca literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js b/apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js new file mode 100644 index 0000000..99ccabc --- /dev/null +++ b/apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js @@ -0,0 +1 @@ +import{w as N,g as T}from"./BeMFXnHE.js";import{e as E}from"./MAY1QfFZ.js";import{E as p}from"./CcUbQ_Wl.js";const y=4,R=5500,F=1500;function x(){const{subscribe:b,update:u}=N([]);let m=1,f=0;const c=new Map,a=new Map,l=new Map;function w(e,s){l.set(e,Date.now());const t=setTimeout(()=>{c.delete(e),l.delete(e),h(e)},s);c.set(e,t)}function g(e){const s=m++,t=Date.now(),o={id:s,createdAt:t,...e};u(n=>{const r=[o,...n];if(r.length>y){for(const i of r.slice(y)){const d=c.get(i.id);d&&clearTimeout(d),c.delete(i.id),a.delete(i.id),l.delete(i.id)}return r.slice(0,y)}return r}),w(s,e.dwellMs)}function h(e){const s=c.get(e);s&&(clearTimeout(s),c.delete(e)),a.delete(e),l.delete(e),u(t=>t.filter(o=>o.id!==e))}function D(e,s){const t=c.get(e);if(!t)return;clearTimeout(t),c.delete(e);const o=l.get(e)??Date.now(),n=Date.now()-o,r=Math.max(200,s-n);a.set(e,{remaining:r})}function C(e){const s=a.get(e);s&&(a.delete(e),w(e,s.remaining))}function S(){for(const e of c.values())clearTimeout(e);c.clear(),a.clear(),l.clear(),u(()=>[])}function _(e){const s=p[e.type]??"#818CF8",t=e.data;switch(e.type){case"DreamCompleted":{const o=Number(t.memories_replayed??0),n=Number(t.connections_found??0),r=Number(t.insights_generated??0),i=Number(t.duration_ms??0),d=[];return d.push(`Replayed ${o} ${o===1?"memory":"memories"}`),n>0&&d.push(`${n} new connection${n===1?"":"s"}`),r>0&&d.push(`${r} insight${r===1?"":"s"}`),{type:e.type,title:"Dream consolidated",body:`${d.join(" · ")} in ${(i/1e3).toFixed(1)}s`,color:s,dwellMs:7e3}}case"ConsolidationCompleted":{const o=Number(t.nodes_processed??0),n=Number(t.decay_applied??0),r=Number(t.embeddings_generated??0),i=Number(t.duration_ms??0),d=[];return n>0&&d.push(`${n} decayed`),r>0&&d.push(`${r} embedded`),{type:e.type,title:"Consolidation swept",body:`${o} node${o===1?"":"s"}${d.length?" · "+d.join(" · "):""} in ${(i/1e3).toFixed(1)}s`,color:s,dwellMs:6e3}}case"ConnectionDiscovered":{const o=Date.now();if(o-f0?`suppression #${o} · Rac1 cascade ~${n} neighbors`:`suppression #${o}`,color:s,dwellMs:5500}}case"MemoryUnsuppressed":{const o=Number(t.remaining_count??0);return{type:e.type,title:"Recovered",body:o>0?`${o} suppression${o===1?"":"s"} remain`:"fully unsuppressed",color:s,dwellMs:5e3}}case"Rac1CascadeSwept":{const o=Number(t.seeds??0),n=Number(t.neighbors_affected??0);return{type:e.type,title:"Rac1 cascade",body:`${o} seed${o===1?"":"s"} · ${n} dendritic spine${n===1?"":"s"} pruned`,color:s,dwellMs:6e3}}case"MemoryDeleted":return{type:e.type,title:"Memory deleted",body:String(t.id??"").slice(0,8),color:s,dwellMs:4e3};case"HookVerdictRecorded":{const o=String(t.verdict??"NOTE"),n=String(t.reason??"Sanhedrin receipt updated");return{type:e.type,title:`Sanhedrin ${o}`,body:n,color:s,dwellMs:o==="VETO"?8e3:R}}case"Heartbeat":case"SearchPerformed":case"RetentionDecayed":case"ActivationSpread":case"ImportanceScored":case"MemoryCreated":case"MemoryUpdated":case"DreamStarted":case"DreamProgress":case"ConsolidationStarted":case"Connected":return null;default:return null}}let M=null;return E.subscribe(e=>{if(e.length===0)return;const s=[];for(const t of e){if(t===M)break;s.push(t)}if(s.length!==0){M=e[0];for(let t=s.length-1;t>=0;t--){const o=_(s[t]);o&&g(o)}}}),{subscribe:b,dismiss:h,clear:S,pauseDwell:D,resumeDwell:C,push:g}}const $=x();function I(){[{type:"DreamCompleted",title:"Dream consolidated",body:"Replayed 127 memories · 43 new connections · 5 insights in 2.4s",color:p.DreamCompleted,dwellMs:7e3},{type:"ConnectionDiscovered",title:"Bridge discovered",body:"semantic · weight 0.87",color:p.ConnectionDiscovered,dwellMs:4500},{type:"MemorySuppressed",title:"Forgetting",body:"suppression #2 · Rac1 cascade ~8 neighbors",color:p.MemorySuppressed,dwellMs:5500},{type:"ConsolidationCompleted",title:"Consolidation swept",body:"892 nodes · 156 decayed · 48 embedded in 1.1s",color:p.ConsolidationCompleted,dwellMs:6e3}].forEach((u,m)=>{setTimeout(()=>{$.push(u)},m*800)}),T($)}export{I as f,$ as t}; diff --git a/apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js.br b/apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js.br new file mode 100644 index 0000000000000000000000000000000000000000..fffecbf06186e02af556fade966edb3924229bb6 GIT binary patch literal 1616 zcmV-W2Cw-W9TET>g-w}zG%i0RyjaUxtRzWYOSS)fUSy-WL8-{@IHh)35o;S4(6FnN z7Pr2yIj0r61v=4+^UtZvMD+vRL}{sh+Lzq7UkdcYLPe@*%D7WWk1Av?Su{@Ap!67bo05*It<$--LzEh92+SxxMX$ z;T<}_`Iy*-+Qsq9eRAI0dC1=`F3N1~u3yj7+e5fB=)WR9G2{!3MoP`?pf^&g6Ux31 z7pJrS4r#l7!;9Z|cgRF(ETk-v zw<6<$JHN}A+&Y>;wfQo}O3H=tsS=6D-y?(PLNX@u`LT=1{POw`mxl?$vE80y__vWg zlHF@!ZhUi{HS>aqnlGJ0j@%ot@P92lt-LK{P*m$yekt|NLBh?kC0~dzwLuy`$=`o7 z*hybmTCw}sn?@rS4@pBDF#&ZP&VC9VE6Y0Q)me%^e}9b;zdK?SlR%F?COY^B5T*#8 zJla?8{Zxl^aMOHV=@|KA0oM3qkNhllKZRu^f7KR`<=w|z-ZU`jA{vBHhLq6Zalk%0 ztnzMe$H*Hq&jI~W{>CJJ$VykuQFbDqB?$dJ_CQAm3*phdLl|LQRST;r+S%k+im_C&Tn z;1g;CarN0c^QjU0Tzb4e1`QU^N>3T7-_X4X!l;Onw-57xm!Pvg=w`X?he`uFHeky%JOnDXy{6#eG@_7Sn##gTPd>a3*ita zxD>r=^}e4r11{ej;OuK)`Uy8nOm8S_g!r29S@E=U=FMjebb2_8t9l1}kLI3O8u!-K z09_)bPiZo6VgsF>)RN6c8a9J*sC5>5=@NVB5NWUC*bUT1O08uF6QRqFNhG#a`kvmD z(ZwP_D8WT&PZV$H1n0_5zSZk0PaSGKl-p(tciYP7&Sw*|q~vm)_)9KkAAl}E-8r5k!sXU4{@T$I zwWQnxiO+E^G)c$&MZ~}ipG^v=k~eMLIaGSsrwo-N5}3z1LDbtWekpC747;wPAtoW& z5@~rX$d! z)c_D%m&b3Bzj?I+|GvGmAKhRuHs_WvOwyve>J6-QHNb?GKAKoe$}$`K`}QuQ8=wiD z4(hN4x5j<2K<~Y}m?9BFuCNE2)BT-r^Ko?wp{3RN1>HmoCA_oXas8VtjbiH{@K54G zPN*$)2Y=04&)L3Zd)Z-HSR3uMh&E|5kwwt8SNbTuE)3diqOfeagxe&64OO2M1(cci zjVLK7T$0~wf34_NcMKT#Pj63;nhl6N*+Qb$9a_e+vf8Cl%B=&#{>|rFB)mBcEFV)@ zy1qkZK?{@pSw#-!Pt8lm(1mh_2d9w%^1=C@=N!s&mc@zcziuQgctzef8hz)<%!o^- zFgvj72VB)<)g>3PB-}~~9eRs-Q%N%}DG@$gTr?fumvMSbbXGGum{q93 znjK8~O<}t7+?h_vF;ozMysv(AQIXdNS!?^@D0CLJFr19njwFh1RUHlWgitMh&x8 za7|AQSgKQL1O literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js.gz b/apps/dashboard/build/_app/immutable/chunks/D4ymNiig.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..896a3b1c1322655083c9a91520708c693fed686c GIT binary patch literal 1770 zcmV@4{}PI)hd(T?f9XLTxiB`t zOXnsyI~xp~>tKj~{-Q`DL0M{ivg~a|wB^N|M>(B?H+PDRgaW*x4BlCH_qHE{Fp^;C zEP{b%83ie%x&A~QeI%!FMwa+bKM>@awcJb&(ppq1sYU`vU|ohS!fB(H@h9M^TB z^b0GMBCCUWaL43wdhgSPmAf&dOR+lN*xLomEk#2OwlH#+$20Pu3}hGCxUeKh(jn%^?YCO4Fr>7_|ysbU_Kb zpmgo7!qjb8bS<1(UH^mhf8>4);{rHFanCeqj$5r*64v@DZk~!N!ZD#*_Oq^j*&VoI zlfnIXY<@l(jxMf8CPp$kI~1YM*HlF4_&z6uvE)%Gtpe+R{a2XlQ z5?*bQ;O^en5lh^x;4AClMvFI&wycytK@bebW~JW7^vqgMvwT4H&IiZG^~s}cS{kyl zw3_0QI*td`iM)RzFAc3WKJSojC4QcQ(GgU{;3*uX0M246YacP4IU^enc@g(lMpMf) z{`lQ6ZOItbx9C?xcwxJOUDHoMtf5`<2Pa}N%dybt=5mwTw%|n>>Og8u$GSPyHF(3_X z;y`&vg00H#Si$|g558xb{|NuDyZGzaxuiT|A0h9d-_{vfy4cC$n`^tqq=;jG5inh< z(qJlbM7WnZGif&_ZA{Y-X3ryQkU=Pc))*f`>f4->B^adDticIgfR-yRXm;Khd}^2b z_P)g4t__}4iS<3s1njQ@4c1r`1f0u!)o9;o!SryF3tm?qt zt7nq^t~KZ;T}D%qQ$ZtxXEcSK{)Kr}q*zBEsb6)n=(h1U5(OXBP>Kf zGhwJZ1~DJO`k_6g0$63lp2`w)^T(^(@67QCUU)Yevo|<(i8+q^rdPdB@jY674>`_r ziL^yUPF*7|Rjbp>ud%RytXkI;!!N9t-&R+yFpXe}h&0p+^$T^s=&iliW_s ze+ldKQU$T24xo%`_5U2)4U=bFv=&qHeytYk(YG1Ekxy?1t0=)TPvjg365yL?< zvFm{pCxdqO6>|2)!4uC2B%auF)ck|b)kuK1G2Gyq*)z#(I|<-!pjb#%@UEw~PlmoY z$GfCBIkB67npyl#;AN8?A1^ItmnGhHdbd*Sj|t`6TRGK0?MQ@|GA075Ae6FS_lu^eqnccPij^N9ZRfLbI7?rKgNxmH6{DDDzYaQ7oe5$_Pyp`W>7S56U6Q%#z MpN*cVBOVd}0NV&`!~g&Q literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/BdslOLCg.js b/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js similarity index 74% rename from apps/dashboard/build/_app/immutable/chunks/BdslOLCg.js rename to apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js index caed2d9..cd5566d 100644 --- a/apps/dashboard/build/_app/immutable/chunks/BdslOLCg.js +++ b/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js @@ -1 +1 @@ -var x=t=>{throw TypeError(t)};var B=(t,e,n)=>e.has(t)||x("Cannot "+n);var a=(t,e,n)=>(B(t,e,"read from private field"),n?n.call(t):e.get(t)),c=(t,e,n)=>e.has(t)?x("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,n);import{o as I}from"./GG5zm9kr.js";import{s as u,g as f,h as d}from"./CpWkWWOo.js";import{w as V}from"./BeMFXnHE.js";new URL("sveltekit-internal://");function ae(t,e){return t==="/"||e==="ignore"?t:e==="never"?t.endsWith("/")?t.slice(0,-1):t:e==="always"&&!t.endsWith("/")?t+"/":t}function oe(t){return t.split("%25").map(decodeURI).join("%25")}function ie(t){for(const e in t)t[e]=decodeURIComponent(t[e]);return t}function le({href:t}){return t.split("#")[0]}function W(...t){let e=5381;for(const n of t)if(typeof n=="string"){let r=n.length;for(;r;)e=e*33^n.charCodeAt(--r)}else if(ArrayBuffer.isView(n)){const r=new Uint8Array(n.buffer,n.byteOffset,n.byteLength);let s=r.length;for(;s;)e=e*33^r[--s]}else throw new TypeError("value must be a string or TypedArray");return(e>>>0).toString(36)}new TextEncoder;new TextDecoder;function X(t){const e=atob(t),n=new Uint8Array(e.length);for(let r=0;r((t instanceof Request?t.method:(e==null?void 0:e.method)||"GET")!=="GET"&&b.delete(U(t)),z(t,e));const b=new Map;function ce(t,e){const n=U(t,e),r=document.querySelector(n);if(r!=null&&r.textContent){r.remove();let{body:s,...l}=JSON.parse(r.textContent);const o=r.getAttribute("data-ttl");return o&&b.set(n,{body:s,init:l,ttl:1e3*Number(o)}),r.getAttribute("data-b64")!==null&&(s=X(s)),Promise.resolve(new Response(s,l))}return window.fetch(t,e)}function ue(t,e,n){if(b.size>0){const r=U(t,n),s=b.get(r);if(s){if(performance.now()o)}function s(o){n=!1,e.set(o)}function l(o){let i;return e.subscribe(h=>{(i===void 0||n&&h!==i)&&o(i=h)})}return{notify:r,set:s,subscribe:l}}const D={v:()=>{}};function Re(){const{set:t,subscribe:e}=V(!1);let n;async function r(){clearTimeout(n);try{const s=await fetch(`${M}/_app/version.json`,{headers:{pragma:"no-cache","cache-control":"no-cache"}});if(!s.ok)return!1;const o=(await s.json()).version!==F;return o&&(t(!0),D.v(),clearTimeout(n)),o}catch{return!1}}return{subscribe:e,check:r}}function Q(t,e,n){return t.origin!==G||!t.pathname.startsWith(e)?!0:n?t.pathname!==location.pathname:!1}function Se(t){}const H=new Set(["load","prerender","csr","ssr","trailingSlash","config"]);[...H];const Z=new Set([...H]);[...Z];let E,O,T;const ee=I.toString().includes("$$")||/function \w+\(\) \{\}/.test(I.toString());var _,w,m,p,v,y,A,R,j,S,C,k,P;ee?(E={data:{},form:null,error:null,params:{},route:{id:null},state:{},status:-1,url:new URL("https://example.com")},O={current:null},T={current:!1}):(E=new(j=class{constructor(){c(this,_,u({}));c(this,w,u(null));c(this,m,u(null));c(this,p,u({}));c(this,v,u({id:null}));c(this,y,u({}));c(this,A,u(-1));c(this,R,u(new URL("https://example.com")))}get data(){return f(a(this,_))}set data(e){d(a(this,_),e)}get form(){return f(a(this,w))}set form(e){d(a(this,w),e)}get error(){return f(a(this,m))}set error(e){d(a(this,m),e)}get params(){return f(a(this,p))}set params(e){d(a(this,p),e)}get route(){return f(a(this,v))}set route(e){d(a(this,v),e)}get state(){return f(a(this,y))}set state(e){d(a(this,y),e)}get status(){return f(a(this,A))}set status(e){d(a(this,A),e)}get url(){return f(a(this,R))}set url(e){d(a(this,R),e)}},_=new WeakMap,w=new WeakMap,m=new WeakMap,p=new WeakMap,v=new WeakMap,y=new WeakMap,A=new WeakMap,R=new WeakMap,j),O=new(C=class{constructor(){c(this,S,u(null))}get current(){return f(a(this,S))}set current(e){d(a(this,S),e)}},S=new WeakMap,C),T=new(P=class{constructor(){c(this,k,u(!1))}get current(){return f(a(this,k))}set current(e){d(a(this,k),e)}},k=new WeakMap,P),D.v=()=>T.current=!0);function Ue(t){Object.assign(E,t)}export{be as H,_e as N,ge as P,he as S,ye as a,J as b,Re as c,le as d,ie as e,pe as f,ve as g,ae as h,Q as i,N as j,oe as k,fe as l,ue as m,O as n,G as o,E as p,ce as q,we as r,me as s,de as t,Ae as u,Ue as v,Se as w}; +var x=t=>{throw TypeError(t)};var B=(t,e,n)=>e.has(t)||x("Cannot "+n);var a=(t,e,n)=>(B(t,e,"read from private field"),n?n.call(t):e.get(t)),c=(t,e,n)=>e.has(t)?x("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,n);import{o as I}from"./GG5zm9kr.js";import{s as u,g as f,h as d}from"./CpWkWWOo.js";import{w as G}from"./BeMFXnHE.js";new URL("sveltekit-internal://");function ae(t,e){return t==="/"||e==="ignore"?t:e==="never"?t.endsWith("/")?t.slice(0,-1):t:e==="always"&&!t.endsWith("/")?t+"/":t}function oe(t){return t.split("%25").map(decodeURI).join("%25")}function ie(t){for(const e in t)t[e]=decodeURIComponent(t[e]);return t}function le({href:t}){return t.split("#")[0]}function W(...t){let e=5381;for(const n of t)if(typeof n=="string"){let r=n.length;for(;r;)e=e*33^n.charCodeAt(--r)}else if(ArrayBuffer.isView(n)){const r=new Uint8Array(n.buffer,n.byteOffset,n.byteLength);let s=r.length;for(;s;)e=e*33^r[--s]}else throw new TypeError("value must be a string or TypedArray");return(e>>>0).toString(36)}new TextEncoder;new TextDecoder;function X(t){const e=atob(t),n=new Uint8Array(e.length);for(let r=0;r((t instanceof Request?t.method:(e==null?void 0:e.method)||"GET")!=="GET"&&b.delete(U(t)),z(t,e));const b=new Map;function ce(t,e){const n=U(t,e),r=document.querySelector(n);if(r!=null&&r.textContent){r.remove();let{body:s,...l}=JSON.parse(r.textContent);const o=r.getAttribute("data-ttl");return o&&b.set(n,{body:s,init:l,ttl:1e3*Number(o)}),r.getAttribute("data-b64")!==null&&(s=X(s)),Promise.resolve(new Response(s,l))}return window.fetch(t,e)}function ue(t,e,n){if(b.size>0){const r=U(t,n),s=b.get(r);if(s){if(performance.now()o)}function s(o){n=!1,e.set(o)}function l(o){let i;return e.subscribe(h=>{(i===void 0||n&&h!==i)&&o(i=h)})}return{notify:r,set:s,subscribe:l}}const D={v:()=>{}};function Re(){const{set:t,subscribe:e}=G(!1);let n;async function r(){clearTimeout(n);try{const s=await fetch(`${M}/_app/version.json`,{headers:{pragma:"no-cache","cache-control":"no-cache"}});if(!s.ok)return!1;const o=(await s.json()).version!==F;return o&&(t(!0),D.v(),clearTimeout(n)),o}catch{return!1}}return{subscribe:e,check:r}}function Q(t,e,n){return t.origin!==Y||!t.pathname.startsWith(e)?!0:n?t.pathname!==location.pathname:!1}function Se(t){}const H=new Set(["load","prerender","csr","ssr","trailingSlash","config"]);[...H];const Z=new Set([...H]);[...Z];let E,O,T;const ee=I.toString().includes("$$")||/function \w+\(\) \{\}/.test(I.toString());var _,m,w,p,v,y,A,R,P,S,V,k,j;ee?(E={data:{},form:null,error:null,params:{},route:{id:null},state:{},status:-1,url:new URL("https://example.com")},O={current:null},T={current:!1}):(E=new(P=class{constructor(){c(this,_,u({}));c(this,m,u(null));c(this,w,u(null));c(this,p,u({}));c(this,v,u({id:null}));c(this,y,u({}));c(this,A,u(-1));c(this,R,u(new URL("https://example.com")))}get data(){return f(a(this,_))}set data(e){d(a(this,_),e)}get form(){return f(a(this,m))}set form(e){d(a(this,m),e)}get error(){return f(a(this,w))}set error(e){d(a(this,w),e)}get params(){return f(a(this,p))}set params(e){d(a(this,p),e)}get route(){return f(a(this,v))}set route(e){d(a(this,v),e)}get state(){return f(a(this,y))}set state(e){d(a(this,y),e)}get status(){return f(a(this,A))}set status(e){d(a(this,A),e)}get url(){return f(a(this,R))}set url(e){d(a(this,R),e)}},_=new WeakMap,m=new WeakMap,w=new WeakMap,p=new WeakMap,v=new WeakMap,y=new WeakMap,A=new WeakMap,R=new WeakMap,P),O=new(V=class{constructor(){c(this,S,u(null))}get current(){return f(a(this,S))}set current(e){d(a(this,S),e)}},S=new WeakMap,V),T=new(j=class{constructor(){c(this,k,u(!1))}get current(){return f(a(this,k))}set current(e){d(a(this,k),e)}},k=new WeakMap,j),D.v=()=>T.current=!0);function Ue(t){Object.assign(E,t)}export{be as H,_e as N,ge as P,he as S,ye as a,J as b,Re as c,le as d,ie as e,pe as f,ve as g,ae as h,Q as i,N as j,oe as k,fe as l,ue as m,O as n,Y as o,E as p,ce as q,me as r,we as s,de as t,Ae as u,Ue as v,Se as w}; diff --git a/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.br b/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.br new file mode 100644 index 0000000000000000000000000000000000000000..986afe9f7fd3f3fbf542cdde288dfa5b62a981dd GIT binary patch literal 2609 zcmV-13eNQ#h#4Rp2jzA$2N-tK?*EfPlBE7@>UZDE$tYe%+NGHPyFA3Hos>?%JPfgr zi1chi!0`3u($m$up{eYD6JU*Nb&Kx-mbn8Y152HIC?fwiS5_|MZVMb$;p!{QrYuRR zy3PN8CU0jJUPId#ILO`=woI71+LULtQrTS|5vDCWOFGXC4fObXiAh(bFG6pLTR)-9pMJ*?!@z#CU)TvI{h%bEG8>6hS(LE&sPK%ISs!QQP|xC1AvUZqo#5u%eKr{S0h zl4~M5h5tY9isyN#NdykSKcD;w#%UNKH`I5g8_cIY(&2Ii;mB94E$ssI`Hf@USQzeq zfAT8p^k<^CRR)_#T~{kZDoXmkK{l?07HF?L6&UlVl%`l6?NV?4lK2O;No7s1WoJ3M zM)*cA_ME=I%VsSxlN;-TSw??#T{EPBYVScZYOo~Qo((pVnm~>^!IN21YJ}J;QdqCo z4>b)W&F{}yhS`cw+?568>oI8H4pezJYY2t$I)~k=AM| zO{GG1^dd=#ZR;wgncR=rr0sV}SweJDd`)ifJWr&xBu?Xr>XE1KBxOBEB$8Myv+zt1 zvI><)kcYk`d{DSg;sQJqJc#fAskXMJR>VRDP%F3UB!956PR?85tU@%^bnn_V9I@~d}!5Sl-UMsUc zDIke&m^`Y!{dkmoB6vz`pw|ep7bpCPrZeogf-3tNm3dnaO!Orw8QHcmp^_)h^RiF&RKrjtj}2O3o1-jQI>|f z;$yIR=vBCzd6SRPtHd%#o(@9`2;Usvh+~4@PaK^5l#2>j zDZg&$rF#ZgKOug$XNoUTMT@7p9d7n?JZ`(&)mAmn<)iESiL>Xv)u4WROvoc7LA1E} zpVYQ!$;p_J4OcoD3oAz+r-Wm+!s@AVCVo(wt8`R*br6<7e=rb$Q+KqaDo5FZ zCOCMUMbto%+Y{OLK?B0_-Es5ggi)A9wkhe8X}GQ7bf1K*-fL>v0vD{o91)A$= z#Q?NEfT&z;bS~1gsxJjQ%DANANgI`~T^K5l^hO`{Hw)UCU_l~l^xP(bLw4z~OdzB# z1=+wF;T!p{YfrEK%LAjVUUDj8Dz@Z0!7%s4C*v^I4d2#=U75E#NW9uz{i>tit;FJ% zrk9#t)|taz=LlPR?k&sA{bkYAxYXQJRIrH-L2MF_uoPa!e>N+hsiYeDD(CAE%2XGA zRo6jy?B;Vp@us6?4v0=O_?loNE=X_(H=rNLRY7K3#+w+m>&PWdYeo~Aib|s`dzJF8 zT`t1P%$FJYW{ug2jf!=&XQhPHt$5*ncl8Al25B?~Y8z~eKm%x*V=EahMN*Tl9EB^~ zii9R80(cauc7+XVl)`{?dFhW*w&ms(t;O{-wLNDy0jh$fOL7sMT_f;p;l##9U;3{?Q#X~ z6*QNk^IVL}Lwc)NLB3_{W>&At0J{vcPKM2=P~E>_+3KTW%anNpk!O;vvw|4`hKGCfKYOD|=rv0i9}e%(0uc@&E^ z5<7KS7l7&11iyhMxk_=^UN6j>~OYzTD1d~){>yXU7g)6!wq`twfE9#xN3#hk7 zo$L`BRw%?R@Cn=sqLLAFva*#2+GVLIkUo)mjPimy(}0rVbRloB&v&&_&LWYR0z~Tt z8w_fuu6HodvHln+x-g8)BQV4KUCz12y#OLSY+5S<+#U`keBDpKYa>WG^x6FBO5EHs^Mo*p-KF zCD3qlme8`jFm@fN1gp17Syg-135>nn%PBdx{zn#6{Tc=ZlBlD*v?XeQG^w2mU~G)F zacOLgo5ri=g*dMkV|`nXm>zS-s@3Lls6`w}&1G9;jGDLNIt^p}o}C|^6`aO)-ZnSR z<-1Z5*0kQc>hr|V8re(oMtak$9<0%`7TpDvan-wSr*RAqh!^!UX8Hw%9?=E~M~5)w z3KC8cJ3XV+fm+X5>NAp{;Bp(3obAJRltVZt-|K=!P;tH+E_oQP*bQr@?%@a3PS-TL TA=8mfeZkGpB@r82Rgmo;K{gN4 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.gz b/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..2fd77b7ed6c435c37b2c54b466cf8cecbd3bfc62 GIT binary patch literal 2953 zcmV;43wHD$iwFP!000026O|cjSKB!D`~C{!VRP(3IM7b#%sOK@lrrsfTj&tzV`v5x zTS*L#@R+&4)JeJ0 z6gFbwd|>o$$n+r#fQP+O;gxXHAf4wz>OweFIlq@EtQ+)SzI^s|{;xY3+$y)mP>8W0 zQ(PuwhD%c8ALk$LK72S6UHlbdysR;vv$wx}Dc zfa=3uWogX3J+iy+hZQc(R&=f0UT^Cg^c`42T{a>J5TO+yP`Jr-az&Nw&)&iz4sUCSn8UNMtw z0-}8@%@3}BwKr;!KX^e9z^xgB`=V!0f7u_j0)R>r5Fnj+8iF0ZIT%D~newS?No2%> zjPa?S8M1*K_$*>SK7INZMD2{qV-WgCd%L^RFIlEQqltGUC0##XOeRbQsd}HXmB)R* zuvY>@bU8Tr7lY^VU~Etce5^G)n@k`etIZp8vp+ydR3tYfQH><>YIj$S?DaNv@rpKm z-6hQykRJ=Ue#{)|SPdN^4N_v{aBE9@?BL*F&kwX18Z__e&wgnbvM>6CqnG5M-oIdW z-hp74h{vq}@+sABEBH;}*9=L5O3+B?2RtCS~V z6-=0pXM^s>6cDUHp6(WabN2UwDGj+WXL=@*(1R@Ci!3`_iZpTdpdeTPls5O}$%X50 zK}_IBuQv`72EsD$($uK0<_3RYMHw3<-_pD_MqH(A6>QO^*%BEgB3{fP!~>8;u7|)h z)?f&%K@(4I8F_j=8E7!^v4DEOG4BG&=3>b_6A#5$B@pOR|))RgSN<7AI z{PR!7URHijMISu{hI$8uFI5cWS0V!i&`{@0L7IcSie$cDRx)%QXpGe+@`6lXOuNJdjF|1l zG@dco37)NY(}~?DF0rvO3Q`_ti-akUZw3vvFu?TvIzBfv4A7iJ1!zux&_ofGj7RlG zC0o61&{W0fM#VDC^_8)9+cFFtOGfs5A+u<^Fd<n;FWr>r?c9jpWBhTB8rkNPi>|&Ox z;QG3;=JmdO#vwiZO&4zmW2%^cc0d9>Xg(54oQEKG5l1| z*B5kp3ZtRtA{A6P)^zbh4%0zkriX?Ut}Q!xi{sd4=~+R|tp<(ai?QOzs!gxW?vve> zEyZ+mR@{l9*=`l~iE=};Xt`i+XnnA?H!x>VRx7BftPOa7 zPz^8DK|Mr0aa@rI~#h(8Kd$doink}IO}7rt1Aax(NsHj z{=3;O-j@Aqn&*8e{|XD!trGl(6xA>lf{*ERPD6;&W@I%hWCYjXJGTQWOEU{^sX*NM zP4Lw30?*#8%oU#R2i28exZgT215bNfdp>y)EIpq*Py~{oDugxnCKfy9As|b97s^h= z{888brcc^31$Tdfnusk;&p0+42so+jPZKbLZNb2O*g^rlso?cl2tqXX3{7NKj(ufX z%Me2A$~8%BiUqVzuq>KU;a_F`YDv=!=FwpWTIVY4_t_UZ&og+Ti@EEUG zDjWK8VP3wF9G-?blw6aASCsguw);8kkz0GR`sO5mK(oYstxbEpet>oa``!I^e~yg5 zt0TNqp$R%@)@C4dCLXOs2e7KaFg_(M0H;Z$L`OVAIj<-UxJx;2D2?MDAzf9Z7T%>@ zHMG{#j}Ye-afQ&O&KqhI9gh$%D`E@p(k>fX6G@NIt}9v#@6xU}Xcv!3ebgadY)XC9 zP(#2zLV8}2BD70)ZsJ8?z8bNi|ZGUcS7I^!M>QE*75gD<-CHYE3T*T;KlVFJcn@| zlC@bWd5z1MoSSV-GP5QmH7g@Iv%lpp%{nF2tTXZlE-5+1<(3F@dIv9aTr;vT>zth7 z!pSFG1UbPaC$RzkP3C5mWMx(upv|hu5wrhAxHRjM49&VK2mkmF0X~GEi5UO@6G)1( literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js.br b/apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js.br deleted file mode 100644 index 03be48c45ef38d4861693d3ee2debe6887114397..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 580 zcmV-K0=xYi0tNt##5jiXo3g}i)24ft>7$Z$Rf&{SVAzTi`me7vD%b(`DPfYBhSs@K z7FxgaLxT`u_oVNey z$1&V=2B0>WTpp8Mvf1KcM~`DLNf|y{RA*e$Ex{_?_@}dI4_>9iu>3ENYXbSF$~hHh ze@7A-Ac*8V#1o+}c1!k%PTwlI3oV}{gdIsi2B5H0$viv5-$*y$NNV1nNj< zhXWhk9n$EoV_1AL=V@PdM%D8!k>Yqc_j<`m%qVZeO(^Q0=dx2rTBNZ0N3nyZ zPc-dLDvfsmId>)qcW)x=e)=0z^nJTjB#&hBg*FZXY;Xec1Crfv6uH7HG5};9ISwi} zA+tThNzx*haTzB7 diff --git a/apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js.gz b/apps/dashboard/build/_app/immutable/chunks/DNjM5a-l.js.gz deleted file mode 100644 index 44aee17182489de37c4672a8e9b24406d2984303..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 700 zcmV;t0z>^DiwFP!000026OB|+PunmMe&4SMRy8G>N!eZ|rOK)a`oM$+qUC8q)Fc;r zEU|;_0#%g%zO$2*3d+P&eRucSnUcl^I%Q)~Bbx}bky%izWoA*yz=pt8)MWlA zOvRHx8x&x(Rk$2Ax*avpE_t&8k%Kl#!;Y1-AnoB|Qv*wwsOu6l;cAWVjgqY8aU82Q znqUzgV66T|cBR!*AmJ&PX{~g){CRO2j2euM6?SdfWaqGeXWK5Li3YpYGQil?45PNw zC)1{aN@)aAQlha5q(6G?DupSVvM-M3>hf$3LT9TBp+#jvh+?beR-?QNqlB@cybYJ* zq2Q=dMBMT_@KtxAu^&Rjb11>Wew33kyHa_=PG)Db#f-HPueGYwI|<_++)2DRpD$cm z4)14m*q$V_u4@g(Bz~X!QinfYC-YmCZxS{AH9!ANTW~|dViPtR1kFC7RVI%L^WcbB z)^f|USKbT$R$|MI--%b4emm+#cERaGN(E%5a=5xYJyun%B)N<>*M2UsLYsE`;m#)1 zq)%pJe_|0QdzN;!4R=S1Tdbf&3B;Lx_pAf$fJ}3-F^>Bc&z%Vx(=zrBad#-!Ix z!nv)$(t-}dKOC=#5D(I{n_(1JqNX@<;{f{hwlvXo^dFacIfF%WT1~ZW)}Pp0N5FGk zDh=JZnJ`9W=Sh0#P%qlF;hDAa)Pev?b`P> zS1^@s+SY3Sp diff --git a/apps/dashboard/build/_app/immutable/chunks/DzfRjky4.js.br b/apps/dashboard/build/_app/immutable/chunks/DzfRjky4.js.br deleted file mode 100644 index e2697c31c91ac99924a78ff948caeed7aa3d38a3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 321 zcmV-H0lxkly#iny1@4}g#>3FYNf9)P92vE)UrCQpn8XN8KWuvfYHg)%NH~I?5%9P4 zPnMlN6D|dRkTEs%?&)Q8;aD~%U@33KYOz@HuR0w)CO+yTHY|g#+ZC#nB|k{;{;>YD zhiaCBVOrQ#+-C+#J_vcqOh!eY4BiAUEPD>SX+FM*>PChJ0u*QL%M?dW-nf|Hwa6`GC{5z)t z?H#qn{yIv&x!{XWqNzsL6j=5Vmz(iJ+N$6|f~R$w;yl1_IxlW*S)M&2(wdy!C-byg zu)v(q=dq7F0j}i6qrrg*{Y}B?8{!}<3+l3%0h0)uU*mo)8)(de5)b;nSCJM_-HrCn TkUY!#eaQ2VM0Y8J_n|lfdB~ai diff --git a/apps/dashboard/build/_app/immutable/chunks/DzfRjky4.js.gz b/apps/dashboard/build/_app/immutable/chunks/DzfRjky4.js.gz deleted file mode 100644 index ec4983f4128f88df66eb59909cfd6876890a18fb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 387 zcmV-}0et=+iwFP!000026IGHyZi6roMfW{LM7JzJK;ksY0!*xS(JBhc0bDa_k%EnE zH*FNg_6e3V0}4oVPAshD9Q_8hOdkbS_jNr%x^mUm!gH+a)q*!KohBCJnwCp=1G^asWgJ?{nJW3bYBDjWZeR+pg z=`+>9E!30#p6|Q*&i$yKmv98nZ@q4Ot5vJUMud!pfipHQl5F7BPuFQMrkC<0VdFpc z(oDrT-4Hqt!W|be4(F%5v@Tu!bJvrM}!4$cr@1@BE=pL{f$+Q{1pRHkcYlJ@y;c_#jXHj4d;F zV28DIVhMtu9}-5d1kr1a5$c4OsV5I0N9p8$i=pvpWN&S!wB>m9N+^A6>R-hxMrJ>8 h`QzKUuHes|zpxoMvrP!@^Ko50{R1I)Y~8*B003dlwSE8q diff --git a/apps/dashboard/build/_app/immutable/entry/app.DRELdRUq.js b/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js similarity index 77% rename from apps/dashboard/build/_app/immutable/entry/app.DRELdRUq.js rename to apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js index 3db8b30..319e17d 100644 --- a/apps/dashboard/build/_app/immutable/entry/app.DRELdRUq.js +++ b/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js @@ -1,2 +1,2 @@ -const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["../nodes/0._nbDJIPC.js","../chunks/Bzak7iHL.js","../chunks/GG5zm9kr.js","../chunks/CpWkWWOo.js","../chunks/BlVfL1ME.js","../chunks/CHOnp4oo.js","../chunks/B4yTwGkE.js","../chunks/DdEqwvdI.js","../chunks/CGEBXrjl.js","../chunks/CJCPY1OL.js","../chunks/A7po6GxK.js","../chunks/aVbAZ-t7.js","../chunks/BKuqSeVd.js","../chunks/sZcqyNBA.js","../chunks/CJsMJEun.js","../chunks/C6HuKgyx.js","../chunks/BeMFXnHE.js","../chunks/BTwePnbx.js","../chunks/BdslOLCg.js","../chunks/MAY1QfFZ.js","../chunks/BUoSzNdg.js","../chunks/Cx-f-Pzo.js","../chunks/BjdL4Pm2.js","../chunks/DzfRjky4.js","../chunks/DNjM5a-l.js","../assets/0.IIz8MMYb.css","../nodes/1.Bnre2dw5.js","../nodes/2.D-vKwnTC.js","../nodes/3.De3LPrRR.js","../nodes/4.DJCab_le.js","../chunks/V6gjw5Ec.js","../nodes/5.C0AYWqwr.js","../chunks/BnXDGOmJ.js","../assets/5.DQ_AfUnN.css","../nodes/6.BN-BfASZ.js","../chunks/C4h_mRt2.js","../assets/6.BSSBWVKL.css","../nodes/7.jHtvjgRi.js","../assets/7.CCrNEDd3.css","../nodes/8.CgPowUzz.js","../nodes/9.BWaJ-VBd.js","../assets/9.BBx09UGv.css","../nodes/10.CecvzcnA.js","../nodes/11.BbfUOvv5.js","../nodes/12.DaxyVsV4.js","../nodes/13.D52bbIQQ.js","../assets/13.Bjd0S47S.css","../nodes/14.DUh3SXOF.js","../nodes/15.C7Fk4d1G.js","../assets/15.ChjqzJHo.css","../nodes/16.DeYkCVEo.js","../assets/16.BnHgRQtR.css","../nodes/17.CLL0vjL4.js","../nodes/18.CXHHR36X.js","../nodes/19.D4UHDxxJ.js","../nodes/20.BM_Hn1tR.js","../assets/20.DKhUrxcR.css"])))=>i.map(i=>d[i]); -var Q=r=>{throw TypeError(r)};var X=(r,t,e)=>t.has(r)||Q("Cannot "+e);var l=(r,t,e)=>(X(r,t,"read from private field"),e?e.call(r):t.get(r)),H=(r,t,e)=>t.has(r)?Q("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(r):t.set(r,e),W=(r,t,e,n)=>(X(r,t,"write to private field"),n?n.call(r,e):t.set(r,e),e);import{N as Z,ab as ut,b as _t,E as ct,ac as lt,ae as dt,T as ft,R as $,ax as vt,U as ht,h as U,L as pt,g as h,bc as Et,G as gt,I as Pt,p as Rt,aA as yt,aB as Ot,$ as At,f as L,e as Tt,a as bt,s as z,d as Lt,r as It,u as x,t as Dt}from"../chunks/CpWkWWOo.js";import{h as Vt,m as wt,u as kt,s as xt}from"../chunks/BlVfL1ME.js";import"../chunks/Bzak7iHL.js";import{o as St}from"../chunks/GG5zm9kr.js";import{i as B}from"../chunks/B4yTwGkE.js";import{a as g,c as V,f as et,t as jt}from"../chunks/CHOnp4oo.js";import{B as Ct}from"../chunks/DdEqwvdI.js";import{b as S}from"../chunks/CJsMJEun.js";import{p as N}from"../chunks/V6gjw5Ec.js";function j(r,t,e){var n;Z&&(n=ht,ut());var i=new Ct(r);_t(()=>{var c=t()??null;if(Z){var s=lt(n),a=s===vt,m=c!==null;if(a!==m){var R=dt();ft(R),i.anchor=R,$(!1),i.ensure(c,c&&(u=>e(u,c))),$(!0);return}}i.ensure(c,c&&(u=>e(u,c)))},ct)}function Bt(r){return class extends Nt{constructor(t){super({component:r,...t})}}}var P,d;class Nt{constructor(t){H(this,P);H(this,d);var c;var e=new Map,n=(s,a)=>{var m=Pt(a,!1,!1);return e.set(s,m),m};const i=new Proxy({...t.props||{},$$events:{}},{get(s,a){return h(e.get(a)??n(a,Reflect.get(s,a)))},has(s,a){return a===pt?!0:(h(e.get(a)??n(a,Reflect.get(s,a))),Reflect.has(s,a))},set(s,a,m){return U(e.get(a)??n(a,m),m),Reflect.set(s,a,m)}});W(this,d,(t.hydrate?Vt:wt)(t.component,{target:t.target,anchor:t.anchor,props:i,context:t.context,intro:t.intro??!1,recover:t.recover,transformError:t.transformError})),(!((c=t==null?void 0:t.props)!=null&&c.$$host)||t.sync===!1)&&Et(),W(this,P,i.$$events);for(const s of Object.keys(l(this,d)))s==="$set"||s==="$destroy"||s==="$on"||gt(this,s,{get(){return l(this,d)[s]},set(a){l(this,d)[s]=a},enumerable:!0});l(this,d).$set=s=>{Object.assign(i,s)},l(this,d).$destroy=()=>{kt(l(this,d))}}$set(t){l(this,d).$set(t)}$on(t,e){l(this,P)[t]=l(this,P)[t]||[];const n=(...i)=>e.call(this,...i);return l(this,P)[t].push(n),()=>{l(this,P)[t]=l(this,P)[t].filter(i=>i!==n)}}$destroy(){l(this,d).$destroy()}}P=new WeakMap,d=new WeakMap;const Ut="modulepreload",qt=function(r,t){return new URL(r,t).href},tt={},o=function(t,e,n){let i=Promise.resolve();if(e&&e.length>0){let s=function(u){return Promise.all(u.map(p=>Promise.resolve(p).then(y=>({status:"fulfilled",value:y}),y=>({status:"rejected",reason:y}))))};const a=document.getElementsByTagName("link"),m=document.querySelector("meta[property=csp-nonce]"),R=(m==null?void 0:m.nonce)||(m==null?void 0:m.getAttribute("nonce"));i=s(e.map(u=>{if(u=qt(u,n),u in tt)return;tt[u]=!0;const p=u.endsWith(".css"),y=p?'[rel="stylesheet"]':"";if(!!n)for(let O=a.length-1;O>=0;O--){const _=a[O];if(_.href===u&&(!p||_.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${u}"]${y}`))return;const E=document.createElement("link");if(E.rel=p?"stylesheet":Ut,p||(E.as="script"),E.crossOrigin="",E.href=u,R&&E.setAttribute("nonce",R),document.head.appendChild(E),p)return new Promise((O,_)=>{E.addEventListener("load",O),E.addEventListener("error",()=>_(new Error(`Unable to preload CSS for ${u}`)))})}))}function c(s){const a=new Event("vite:preloadError",{cancelable:!0});if(a.payload=s,window.dispatchEvent(a),!a.defaultPrevented)throw s}return i.then(s=>{for(const a of s||[])a.status==="rejected"&&c(a.reason);return t().catch(c)})},ae={};var Ft=et('

'),Gt=et(" ",1);function Yt(r,t){Rt(t,!0);let e=N(t,"components",23,()=>[]),n=N(t,"data_0",3,null),i=N(t,"data_1",3,null),c=N(t,"data_2",3,null);yt(()=>t.stores.page.set(t.page)),Ot(()=>{t.stores,t.page,t.constructors,e(),t.form,n(),i(),c(),t.stores.page.notify()});let s=z(!1),a=z(!1),m=z(null);St(()=>{const _=t.stores.page.subscribe(()=>{h(s)&&(U(a,!0),At().then(()=>{U(m,document.title||"untitled page",!0)}))});return U(s,!0),_});const R=x(()=>t.constructors[2]);var u=Gt(),p=L(u);{var y=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params},children:(f,Wt)=>{var K=V(),at=L(K);{var st=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params},children:(v,zt)=>{var M=V(),nt=L(M);j(nt,()=>h(R),(it,mt)=>{S(mt(it,{get data(){return c()},get form(){return t.form},get params(){return t.page.params}}),C=>e()[2]=C,()=>{var C;return(C=e())==null?void 0:C[2]})}),g(v,M)},$$slots:{default:!0}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)},ot=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)};B(at,D=>{t.constructors[2]?D(st):D(ot,!1)})}g(f,K)},$$slots:{default:!0}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)},J=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)};B(p,_=>{t.constructors[1]?_(y):_(J,!1)})}var E=Tt(p,2);{var O=_=>{var A=Ft(),T=Lt(A);{var w=b=>{var I=jt();Dt(()=>xt(I,h(m))),g(b,I)};B(T,b=>{h(a)&&b(w)})}It(A),g(_,A)};B(E,_=>{h(s)&&_(O)})}g(r,u),bt()}const se=Bt(Yt),oe=[()=>o(()=>import("../nodes/0._nbDJIPC.js"),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]),import.meta.url),()=>o(()=>import("../nodes/1.Bnre2dw5.js"),__vite__mapDeps([26,1,20,3,4,5,18,2,16,17]),import.meta.url),()=>o(()=>import("../nodes/2.D-vKwnTC.js"),__vite__mapDeps([27,1,3,5,9,7]),import.meta.url),()=>o(()=>import("../nodes/3.De3LPrRR.js"),__vite__mapDeps([28,1,20,3,2,17,16,18]),import.meta.url),()=>o(()=>import("../nodes/4.DJCab_le.js"),__vite__mapDeps([29,1,2,3,4,5,6,7,10,13,24,19,16,8,30,15,23]),import.meta.url),()=>o(()=>import("../nodes/5.C0AYWqwr.js"),__vite__mapDeps([31,1,3,4,5,6,7,8,11,12,21,32,10,30,15,16,33]),import.meta.url),()=>o(()=>import("../nodes/6.BN-BfASZ.js"),__vite__mapDeps([34,1,3,4,5,6,7,8,35,10,11,12,24,21,30,15,16,18,2,36]),import.meta.url),()=>o(()=>import("../nodes/7.jHtvjgRi.js"),__vite__mapDeps([37,1,2,3,4,5,6,7,8,10,13,11,12,21,23,38]),import.meta.url),()=>o(()=>import("../nodes/8.CgPowUzz.js"),__vite__mapDeps([39,1,3,4,5,6,7,8,10,11,12,21,13,24]),import.meta.url),()=>o(()=>import("../nodes/9.BWaJ-VBd.js"),__vite__mapDeps([40,1,20,3,4,5,6,7,8,21,12,15,16,19,23,10,11,30,41]),import.meta.url),()=>o(()=>import("../nodes/10.CecvzcnA.js"),__vite__mapDeps([42,1,2,3,4,5,6,7,8,10,11,12,21,13,32,15,16,18,14,30,23,20,24,19]),import.meta.url),()=>o(()=>import("../nodes/11.BbfUOvv5.js"),__vite__mapDeps([43,1,2,3,4,5,6,7,8,21,12,13,17,16,18,24,23,10,30,15]),import.meta.url),()=>o(()=>import("../nodes/12.DaxyVsV4.js"),__vite__mapDeps([44,1,2,3,4,5,6,7,8,11,12,24]),import.meta.url),()=>o(()=>import("../nodes/13.D52bbIQQ.js"),__vite__mapDeps([45,1,2,3,4,5,6,7,8,10,11,12,21,13,32,24,23,46]),import.meta.url),()=>o(()=>import("../nodes/14.DUh3SXOF.js"),__vite__mapDeps([47,1,2,3,4,5,6,7,8,10,11,12,21]),import.meta.url),()=>o(()=>import("../nodes/15.C7Fk4d1G.js"),__vite__mapDeps([48,1,2,3,4,5,6,7,8,35,10,21,12,13,14,24,11,30,15,16,23,49]),import.meta.url),()=>o(()=>import("../nodes/16.DeYkCVEo.js"),__vite__mapDeps([50,1,2,3,4,5,6,7,8,11,12,24,10,21,30,15,16,23,51]),import.meta.url),()=>o(()=>import("../nodes/17.CLL0vjL4.js"),__vite__mapDeps([52,1,2,3,4,5,6,7,8,11,12,21,15,16,24,19,22,23]),import.meta.url),()=>o(()=>import("../nodes/18.CXHHR36X.js"),__vite__mapDeps([53,1,2,3,4,5,6,7,8,21,12,24]),import.meta.url),()=>o(()=>import("../nodes/19.D4UHDxxJ.js"),__vite__mapDeps([54,1,2,3,4,5,6,7,8,21,12,32,24,23]),import.meta.url),()=>o(()=>import("../nodes/20.BM_Hn1tR.js"),__vite__mapDeps([55,1,2,3,4,5,6,7,8,35,10,11,12,21,13,32,14,18,16,56]),import.meta.url)],ne=[],ie={"/":[3],"/(app)/activation":[4,[2]],"/(app)/contradictions":[5,[2]],"/(app)/dreams":[6,[2]],"/(app)/duplicates":[7,[2]],"/(app)/explore":[8,[2]],"/(app)/feed":[9,[2]],"/(app)/graph":[10,[2]],"/(app)/importance":[11,[2]],"/(app)/intentions":[12,[2]],"/(app)/memories":[13,[2]],"/(app)/patterns":[14,[2]],"/(app)/reasoning":[15,[2]],"/(app)/schedule":[16,[2]],"/(app)/settings":[17,[2]],"/(app)/stats":[18,[2]],"/(app)/timeline":[19,[2]],"/waitlist":[20]},rt={handleError:(({error:r})=>{console.error(r)}),reroute:(()=>{}),transport:{}},Ht=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.decode])),me=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.encode])),ue=!1,_e=(r,t)=>Ht[r](t);export{_e as decode,Ht as decoders,ie as dictionary,me as encoders,ue as hash,rt as hooks,ae as matchers,oe as nodes,se as root,ne as server_loads}; +const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["../nodes/0.BSxKGxRx.js","../chunks/Bzak7iHL.js","../chunks/GG5zm9kr.js","../chunks/CpWkWWOo.js","../chunks/BlVfL1ME.js","../chunks/CHOnp4oo.js","../chunks/B4yTwGkE.js","../chunks/DdEqwvdI.js","../chunks/CGEBXrjl.js","../chunks/CJCPY1OL.js","../chunks/A7po6GxK.js","../chunks/aVbAZ-t7.js","../chunks/BKuqSeVd.js","../chunks/sZcqyNBA.js","../chunks/CJsMJEun.js","../chunks/C6HuKgyx.js","../chunks/BeMFXnHE.js","../chunks/D-gDZzN6.js","../chunks/DGcYlAAw.js","../chunks/MAY1QfFZ.js","../chunks/BUoSzNdg.js","../chunks/Cx-f-Pzo.js","../chunks/D4ymNiig.js","../chunks/CcUbQ_Wl.js","../chunks/554JRhq6.js","../assets/0.CN9L-NIY.css","../nodes/1.CJFfVX1H.js","../nodes/2.D-vKwnTC.js","../nodes/3.mK8D6pz1.js","../nodes/4.DPhwyLUO.js","../chunks/V6gjw5Ec.js","../nodes/5.C0AYWqwr.js","../chunks/BnXDGOmJ.js","../assets/5.DQ_AfUnN.css","../nodes/6.BD0AetaD.js","../chunks/C4h_mRt2.js","../assets/6.BSSBWVKL.css","../nodes/7.2YrTacps.js","../assets/7.CCrNEDd3.css","../nodes/8.CokrlgDp.js","../nodes/9.Vu2AXN40.js","../assets/9.BBx09UGv.css","../nodes/10.CjP_ylq3.js","../nodes/11.k15P8M2H.js","../nodes/12.BthmSU_R.js","../nodes/13.C0fh4g_5.js","../assets/13.Bjd0S47S.css","../nodes/14.DUh3SXOF.js","../nodes/15.QNRJhGzj.js","../assets/15.ChjqzJHo.css","../nodes/16.QhdtMP78.js","../assets/16.BnHgRQtR.css","../nodes/17.DlzXJVdF.js","../nodes/18.Bmu4OWRV.js","../nodes/19.Baocji37.js","../nodes/20.CJQuAMkU.js","../assets/20.DKhUrxcR.css"])))=>i.map(i=>d[i]); +var Q=r=>{throw TypeError(r)};var X=(r,t,e)=>t.has(r)||Q("Cannot "+e);var l=(r,t,e)=>(X(r,t,"read from private field"),e?e.call(r):t.get(r)),H=(r,t,e)=>t.has(r)?Q("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(r):t.set(r,e),W=(r,t,e,n)=>(X(r,t,"write to private field"),n?n.call(r,e):t.set(r,e),e);import{N as Z,ab as ut,b as _t,E as ct,ac as lt,ae as dt,T as ft,R as $,ax as vt,U as ht,h as U,L as pt,g as h,bc as Et,G as gt,I as Pt,p as Rt,aA as yt,aB as Ot,$ as At,f as L,e as Tt,a as bt,s as z,d as Lt,r as It,u as x,t as Dt}from"../chunks/CpWkWWOo.js";import{h as Vt,m as wt,u as kt,s as xt}from"../chunks/BlVfL1ME.js";import"../chunks/Bzak7iHL.js";import{o as St}from"../chunks/GG5zm9kr.js";import{i as B}from"../chunks/B4yTwGkE.js";import{a as g,c as V,f as et,t as jt}from"../chunks/CHOnp4oo.js";import{B as Ct}from"../chunks/DdEqwvdI.js";import{b as S}from"../chunks/CJsMJEun.js";import{p as N}from"../chunks/V6gjw5Ec.js";function j(r,t,e){var n;Z&&(n=ht,ut());var i=new Ct(r);_t(()=>{var c=t()??null;if(Z){var s=lt(n),a=s===vt,m=c!==null;if(a!==m){var R=dt();ft(R),i.anchor=R,$(!1),i.ensure(c,c&&(u=>e(u,c))),$(!0);return}}i.ensure(c,c&&(u=>e(u,c)))},ct)}function Bt(r){return class extends Nt{constructor(t){super({component:r,...t})}}}var P,d;class Nt{constructor(t){H(this,P);H(this,d);var c;var e=new Map,n=(s,a)=>{var m=Pt(a,!1,!1);return e.set(s,m),m};const i=new Proxy({...t.props||{},$$events:{}},{get(s,a){return h(e.get(a)??n(a,Reflect.get(s,a)))},has(s,a){return a===pt?!0:(h(e.get(a)??n(a,Reflect.get(s,a))),Reflect.has(s,a))},set(s,a,m){return U(e.get(a)??n(a,m),m),Reflect.set(s,a,m)}});W(this,d,(t.hydrate?Vt:wt)(t.component,{target:t.target,anchor:t.anchor,props:i,context:t.context,intro:t.intro??!1,recover:t.recover,transformError:t.transformError})),(!((c=t==null?void 0:t.props)!=null&&c.$$host)||t.sync===!1)&&Et(),W(this,P,i.$$events);for(const s of Object.keys(l(this,d)))s==="$set"||s==="$destroy"||s==="$on"||gt(this,s,{get(){return l(this,d)[s]},set(a){l(this,d)[s]=a},enumerable:!0});l(this,d).$set=s=>{Object.assign(i,s)},l(this,d).$destroy=()=>{kt(l(this,d))}}$set(t){l(this,d).$set(t)}$on(t,e){l(this,P)[t]=l(this,P)[t]||[];const n=(...i)=>e.call(this,...i);return l(this,P)[t].push(n),()=>{l(this,P)[t]=l(this,P)[t].filter(i=>i!==n)}}$destroy(){l(this,d).$destroy()}}P=new WeakMap,d=new WeakMap;const Ut="modulepreload",qt=function(r,t){return new URL(r,t).href},tt={},o=function(t,e,n){let i=Promise.resolve();if(e&&e.length>0){let s=function(u){return Promise.all(u.map(p=>Promise.resolve(p).then(y=>({status:"fulfilled",value:y}),y=>({status:"rejected",reason:y}))))};const a=document.getElementsByTagName("link"),m=document.querySelector("meta[property=csp-nonce]"),R=(m==null?void 0:m.nonce)||(m==null?void 0:m.getAttribute("nonce"));i=s(e.map(u=>{if(u=qt(u,n),u in tt)return;tt[u]=!0;const p=u.endsWith(".css"),y=p?'[rel="stylesheet"]':"";if(!!n)for(let O=a.length-1;O>=0;O--){const _=a[O];if(_.href===u&&(!p||_.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${u}"]${y}`))return;const E=document.createElement("link");if(E.rel=p?"stylesheet":Ut,p||(E.as="script"),E.crossOrigin="",E.href=u,R&&E.setAttribute("nonce",R),document.head.appendChild(E),p)return new Promise((O,_)=>{E.addEventListener("load",O),E.addEventListener("error",()=>_(new Error(`Unable to preload CSS for ${u}`)))})}))}function c(s){const a=new Event("vite:preloadError",{cancelable:!0});if(a.payload=s,window.dispatchEvent(a),!a.defaultPrevented)throw s}return i.then(s=>{for(const a of s||[])a.status==="rejected"&&c(a.reason);return t().catch(c)})},ae={};var Ft=et('
'),Gt=et(" ",1);function Yt(r,t){Rt(t,!0);let e=N(t,"components",23,()=>[]),n=N(t,"data_0",3,null),i=N(t,"data_1",3,null),c=N(t,"data_2",3,null);yt(()=>t.stores.page.set(t.page)),Ot(()=>{t.stores,t.page,t.constructors,e(),t.form,n(),i(),c(),t.stores.page.notify()});let s=z(!1),a=z(!1),m=z(null);St(()=>{const _=t.stores.page.subscribe(()=>{h(s)&&(U(a,!0),At().then(()=>{U(m,document.title||"untitled page",!0)}))});return U(s,!0),_});const R=x(()=>t.constructors[2]);var u=Gt(),p=L(u);{var y=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params},children:(f,Wt)=>{var K=V(),at=L(K);{var st=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params},children:(v,zt)=>{var M=V(),nt=L(M);j(nt,()=>h(R),(it,mt)=>{S(mt(it,{get data(){return c()},get form(){return t.form},get params(){return t.page.params}}),C=>e()[2]=C,()=>{var C;return(C=e())==null?void 0:C[2]})}),g(v,M)},$$slots:{default:!0}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)},ot=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)};B(at,D=>{t.constructors[2]?D(st):D(ot,!1)})}g(f,K)},$$slots:{default:!0}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)},J=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)};B(p,_=>{t.constructors[1]?_(y):_(J,!1)})}var E=Tt(p,2);{var O=_=>{var A=Ft(),T=Lt(A);{var w=b=>{var I=jt();Dt(()=>xt(I,h(m))),g(b,I)};B(T,b=>{h(a)&&b(w)})}It(A),g(_,A)};B(E,_=>{h(s)&&_(O)})}g(r,u),bt()}const se=Bt(Yt),oe=[()=>o(()=>import("../nodes/0.BSxKGxRx.js"),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]),import.meta.url),()=>o(()=>import("../nodes/1.CJFfVX1H.js"),__vite__mapDeps([26,1,20,3,4,5,18,2,16,17]),import.meta.url),()=>o(()=>import("../nodes/2.D-vKwnTC.js"),__vite__mapDeps([27,1,3,5,9,7]),import.meta.url),()=>o(()=>import("../nodes/3.mK8D6pz1.js"),__vite__mapDeps([28,1,20,3,2,17,16,18]),import.meta.url),()=>o(()=>import("../nodes/4.DPhwyLUO.js"),__vite__mapDeps([29,1,2,3,4,5,6,7,10,13,24,19,16,8,30,15,23]),import.meta.url),()=>o(()=>import("../nodes/5.C0AYWqwr.js"),__vite__mapDeps([31,1,3,4,5,6,7,8,11,12,21,32,10,30,15,16,33]),import.meta.url),()=>o(()=>import("../nodes/6.BD0AetaD.js"),__vite__mapDeps([34,1,3,4,5,6,7,8,35,10,11,12,24,21,30,15,16,18,2,36]),import.meta.url),()=>o(()=>import("../nodes/7.2YrTacps.js"),__vite__mapDeps([37,1,2,3,4,5,6,7,8,10,13,11,12,21,23,38]),import.meta.url),()=>o(()=>import("../nodes/8.CokrlgDp.js"),__vite__mapDeps([39,1,3,4,5,6,7,8,10,11,12,21,13,24]),import.meta.url),()=>o(()=>import("../nodes/9.Vu2AXN40.js"),__vite__mapDeps([40,1,20,3,4,5,6,7,8,21,12,15,16,19,23,10,11,30,41]),import.meta.url),()=>o(()=>import("../nodes/10.CjP_ylq3.js"),__vite__mapDeps([42,1,2,3,4,5,6,7,8,10,11,12,21,13,32,15,16,18,14,30,23,20,24,19]),import.meta.url),()=>o(()=>import("../nodes/11.k15P8M2H.js"),__vite__mapDeps([43,1,2,3,4,5,6,7,8,21,12,13,17,16,18,24,23,10,30,15]),import.meta.url),()=>o(()=>import("../nodes/12.BthmSU_R.js"),__vite__mapDeps([44,1,2,3,4,5,6,7,8,11,12,24]),import.meta.url),()=>o(()=>import("../nodes/13.C0fh4g_5.js"),__vite__mapDeps([45,1,2,3,4,5,6,7,8,10,11,12,21,13,32,24,23,46]),import.meta.url),()=>o(()=>import("../nodes/14.DUh3SXOF.js"),__vite__mapDeps([47,1,2,3,4,5,6,7,8,10,11,12,21]),import.meta.url),()=>o(()=>import("../nodes/15.QNRJhGzj.js"),__vite__mapDeps([48,1,2,3,4,5,6,7,8,35,10,21,12,13,14,24,11,30,15,16,23,49]),import.meta.url),()=>o(()=>import("../nodes/16.QhdtMP78.js"),__vite__mapDeps([50,1,2,3,4,5,6,7,8,11,12,24,10,21,30,15,16,23,51]),import.meta.url),()=>o(()=>import("../nodes/17.DlzXJVdF.js"),__vite__mapDeps([52,1,2,3,4,5,6,7,8,11,12,21,15,16,24,19,22,23]),import.meta.url),()=>o(()=>import("../nodes/18.Bmu4OWRV.js"),__vite__mapDeps([53,1,2,3,4,5,6,7,8,21,12,24]),import.meta.url),()=>o(()=>import("../nodes/19.Baocji37.js"),__vite__mapDeps([54,1,2,3,4,5,6,7,8,21,12,32,24,23]),import.meta.url),()=>o(()=>import("../nodes/20.CJQuAMkU.js"),__vite__mapDeps([55,1,2,3,4,5,6,7,8,35,10,11,12,21,13,32,14,18,16,56]),import.meta.url)],ne=[],ie={"/":[3],"/(app)/activation":[4,[2]],"/(app)/contradictions":[5,[2]],"/(app)/dreams":[6,[2]],"/(app)/duplicates":[7,[2]],"/(app)/explore":[8,[2]],"/(app)/feed":[9,[2]],"/(app)/graph":[10,[2]],"/(app)/importance":[11,[2]],"/(app)/intentions":[12,[2]],"/(app)/memories":[13,[2]],"/(app)/patterns":[14,[2]],"/(app)/reasoning":[15,[2]],"/(app)/schedule":[16,[2]],"/(app)/settings":[17,[2]],"/(app)/stats":[18,[2]],"/(app)/timeline":[19,[2]],"/waitlist":[20]},rt={handleError:(({error:r})=>{console.error(r)}),reroute:(()=>{}),transport:{}},Ht=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.decode])),me=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.encode])),ue=!1,_e=(r,t)=>Ht[r](t);export{_e as decode,Ht as decoders,ie as dictionary,me as encoders,ue as hash,rt as hooks,ae as matchers,oe as nodes,se as root,ne as server_loads}; diff --git a/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.br b/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.br new file mode 100644 index 0000000000000000000000000000000000000000..682afec036b3f1276fb19020596574942cc1c5aa GIT binary patch literal 3574 zcmV;=neRJ=hB(P>-$0m?UhxNXQQir$2B#zWe5d z*>-E0-bj)+EF&bDZ7oa9USFD6(_KJmoPHel(!R^T^dtzGD~*DKD2TO@>Yp|B@Bebc zF8EVBj@n_?>{|8(G13M?;gO|($Za(3?v(a;LFWhBWSjdvOWh`pvAf&e+d{RNMSjpA zf?cp!y8cgRdExN{0IDXfpMunMPN(Yh=g-KVkxpxTyOO=&1%mTQb8GP^89HlZ+T}EHGb~< zdfhZEysyHjtetxy=v8y9Q$DWF%;z@on{DUmEjEpK76x5bK&lclLPl3?f=g4M`9-$* z@SY$dhKo%okFEXj-ZuN_)vg)@wvp7U5<6Be<1CEwZ;k6zKPneg0^2kuemL5+Go;GD z!UBNVrV2vF{Bn^^=+^e8y?;%kh4>Q2RzvE?wbat|m-5Sfnz4ViQynEMY0p@gKZT+l zX*Y$?#E^XTFPQJrj5=T9zFxoxfSNJw9TSs0R}Q+xbnsHX;&Zbxw-}F(jbvUGSO03t zJO8rz#J()Wd~!sC&~NAN?WI-$=JiqvON=MSW(>Y=rQKpYJH#~j3=fRY20A8jX$^a3 z>!sQ@^gUUD7%slQch2M0^dF$xBto6W;`ag4S9@u7-W5OG1T==5d*dDi+L1;G_a-4+ z=$p$=(82^#%Zzv}+C!WS$ecMDS9LGk)7&q0NJ`s{Er?MhqQA-U7oWV*!U(BnZ`wXy z>=={8ZgQ{#ox8K9EaUJcI*^f!tE4&O`^{jyaG4wbicZA>0rlY$(#Sk;Yj>11+z* z7nQ%p;(s~fZ{E!9xBwHipgBU9{tYrS0pS{_(!Uzaq<{bl(VRR07*7SEpj&i&1>#Z#Rrldebd{!sSGajRT)tRN}BU&^bI zy}uNQFyhALWb~8jdUf9NWJoc-$OJtOuE5v_7*X${o&HVf2u}zG_Rf?=xzcRoTzjZN zZ#C!$p6L#tgXFP713&WsZEIhyMi}u=QDvkAl=p3N74F}jJ9#ie?VWciw2$BNI;-C- zaR3C--G7QY?ETOi1yNr8=h6-mCE>Ct)dXK{GXMKfVSJii(HsgEW#RUn>8%`&z`H0u zAr6%%0EwxKHD_=Vb4IqFSatoMdV<~kk3BzCJU+O`Zv!;Nw*w0UvOEBsOH^8F0nJT>Smd8$xgQ?5ewesB^7FEsA=wFu6*qzY(kh@U4m-BHhC z9~$1YL7i$b*ur)ha_Gl{HI?O&xAr*p%^@Y`T4#Tq z*fxIh;m<;p%W&IBjLMHFS3S~+!A<3(9*k2qOiVib7nmy7YzFHB&+7+kCYLt-yaxRN{3@L>^_(VXP?|&@A2K>-R`$2w z>~-%2W%5DCpaHfrd{%Mf))Xtw0tFu(ad@fjuG0T){wqYF{F>LDyOu6#<>p-Eeuhjv z#2v89{1%V*yMx*9eWB)*;D*J3=U4%@)pY$%X8Qz5LSW zhw?*ZwXo8CE_HPZOyKNd@$DBoCD#GIaq+kj2GwQL*04yK>?Iu*5l-i!jsG~>bXzvE zu=?&nL#_^i5a#+eDzdY8uaQN!ToBF}n`(6>+P!m(RXU#1(dk$JDo<$TmQ`-+=8P zX97A?eIHXZ0@+=7QvE)3EklyCP{LnG_{atZTVRNI{4tk}^lzXx0i4z;>#%mh>gv9r z)Jlqy`RT`nyd~fZO1tx2HshYgR5;lKaBOPBGJ4d#FENq1gENIO0}?16YGahf$c+)X zcIa5p8e$kD=R4Zohu;$ly>`ltTbb2CYe`d&FK3FJ(;;nz+xMl~n=b zS`T0A;Qllvw|&@UZ8aD0nM;wX9$hA*(HqgVZ&20=dAUCxNck@BZP|3=0~?X)_l~V+ zf!K*l45x-|w|?)5HF2U(TPO3yU2MWv@)DHYSl4az?=z|@mstUn$+B^~`V>%A09T^Ix1kx2)j zk(hc3{%pk|X6eHD$29O-94ddO#hb7bBt4uqUDN8aUmsoA;P+@)C-RmL@stb=kWclC z_5Wq}n>nGywnUQm=RoYOU_bs(`I1Q5o%X$^;<9%iUYOB2`bjm$77s9s{s%G41`@Td z?eCS?t^=U&V%^bpL*QJ!OPq@Aa;(gLXW~N9vqHv=$y+?hx;~}=pFmUr zM7Ml3AqfcYZ0)N28z1xR$$&K7R;IkRTZVWSOV9X}v6vHo>*Bx2o&?sydpFhOGG0FB zhGd!h17)DU8G8wX(PU|5%eJ+RApk%SBor*z&@dPXBnlHN=yu#m6^+T;AE394qOL|D z$2EE}g2NvDusPk*C1++J+lgniYz)6Hd^3aJ;eY_B{c?S_F2^&&_9p#uh*V3EPPI+( zb{Hwwb%CH6&J?tKgIT7Fpe@5~gx#tyU4Cc=tK3VKXCX@l@BwC@!>IMFiyh5CrI#Cw zec=%TqRpA)y5!OfRP`Jd&zSa`5pd{?O&eX0T3*&6Nqv5^3|>u2vdg zn0HT>HM3;f?1O8)H>;DnxZDi14HZmnGCS{m5?)x~ug}p%@Mbu;ieyGV>7KY<3%WGl z4A+W2+{TvXaFH#HxyOLn2j-Ht`E$A62f^&#wMmh=H|Mk7x4{ettjcPps!iqdgDzFN ze*VC!cz-YzzMS6H?H?W7y|t$~sGLC<2j z-7Vp6v3bu&CoCE|0y<$aVt*tY><2N{bY=tt7I6Ds(%FJy7p7Esw2my7Vu{X($6D=3qn<4qdL=@aMS#-=`fIK~XU}~%;A><(Ii%Zpl1X1H9l1CR2&X-#(l3P;m-D+7j13zX`r_*;B?Q}dNY|t>)6^D3w21qPj z@wD#eC;r!;WKH|-2NsRL7qo+$_p_t-*1Pr+%LE5ZJMmxR?*|{o>y~qTo`oMBRX@C) z*C-1=3?E(}9BWy<{&8O3jb7vT$K_@Yeq=tn`}>0|{9^yH__O=tcMktuaPx6#^>X~Y zZ*(`VKXUqSREFNA>(otCiE1{Wjy%h-1povkotJ&NnVk9yK#ghlI}+ zwZqdN-TPm~A3HW(F!+&X;zM^*7(`k@80>BSvfYfgGOPWGNX~xRmJXjEmq3n zf)zJ62M_mW=UH4^TIn&mHOw&1uG!KK52MRw!zyRjY-@+XYvlGCVMfRu?LH~(|GKOc zvdDI{gM;_N&fQTzXB4p4%XMeyzLhiBibd_USiRo9C}r(cENKVK_HOPvt?Wn{^xU;8 zy-qdD0t_9zScRL))=iEFFz20JzWH_aBa5%9{k&|Q+D9KRIecJJ`{nK9^f<`j+thyA z7Q49K+Rm*4Q~1Zd)=$>Tt=iHW?#Hjwdn?Dqwsznpm8*x=eRc#CYXs(tQ{Kw@H0bs8 zXR?3sdY9z^h8kz~UG#1W9@?s^>bs5xIa_h`UF*qdtMxznMkM{zBYk(o>?jyWx5JP& zqbP`!NFCR4^p~zggb@mhnPwX?419k6ROCa$_X8%$|4UUq&z;Rve(|mxQNxnDQQ%2o zx*yvI+V(B+Ap0Q0B;cbVJCblLchKU^)Iutt=Be&Rg8EIj=PKW(2^r~eFnQ*9nv5J_+hgPe+iONbY+HbTA3H+#V)0Q%B5Y3>Nw9q<44VcUqdmXam?tXW4Bs>2VLM1Myru-+b13Hb@D#-t zmBNHTfQW8#h~|rj$y5iY9^^>Ql>w8PTn#=l7p_H}Os81iti=hR+D&(Xaph_D%71aG-=Kst8g?_vrw5 zgdnJQn4*Bs^U0$(me>FMU0u1{te(D%g5mTm!p zdY36Jl{gy2ogGAai>xbaMFdbkP9mz9!~~uaeU~Z;F(D!0go0X+C`%%LJpOv(n3zl* zPbED-2}WX>WV(>@B>K*%Z-K7Z$i&JuN=yc6jH#nI32CGN6g28npVcCwX&M`=0UTwZ>FvTcJE}8fZ44)uLUO znj)9tJX9H`(D^k6STSUKYlWKf@0U+O6D)vG2w;E+6O?xuJSg03>1_UZtkxe=4H5;A z4y_0h>)t)94VVgmsddPR84;j_>?%4$coRH}4&f@QIRsS5!0I(z%zMP~SrouCZ};{< z{}DBVKE=gpkFdz_<8Bane49fm3xF|5uB<5vM1=74y?)?WQlXZbMqT63Z{JL9eccXX z2D>2$I`mCYE?E29wt0|e4yfzRTg`l7IWr4}Z!jp>TB^d$kU>$nW^0n|VaCNtzW6-HTLc?ukl zuX&ha8G*5G%|E5Q-Z5SF0xNN87*RJcESbD9eUh&*FHa4Gi|<0^7<$l%kA~iaQydVc`8|RW(*Uo%4ll0iM5ceCg&pDo9Ci- z2bCwNz6luv*fS$11lC9sumo{@6*)b}*JT+1oP&h4AXDN7k+Tbd5@O1O4Mzyg2t!cz zq3yVq(o{*P&P7t{%8GJDIvDp&tnr(eaL=6>DguafS;XTNa+4pVnDu3zG&%}m6vv;x z?|e*;;t;?iS~|SBk-&fwD(`RfbNHF7NlYc4SkT}Zf)i3?d{tIUaWn<7k%=c0cb0## zn$kjJh;#Iq3>@DI2Abu>p}|aBATm_4W@r}e8i~uUBfhCnOBLs~c%16Q5s{1;e74;f zxZT8Nr*1=22%S45$I<{L6Csl4F6j z`xH{@1|HKu88nh5BXW!l*XdJT#^Y$jpqoMs1_m>A8Hy|baSzhvFo+#gVofrhAtiw~ z)Fqd8SxqX`!2}_1P1k`A?Bh%+Nc=|?zzxunUBeR}uvIPm4}fv2@4CUDCfSZv|(?J!l16H!0CcBFpfXJY!;brecx}0RwsM4lCt?O7_v=xbyPS zJH?x&0p>85etyb{&wG}H_+(s$Avkr}JE%4hRR=(Vg_i!FDr#Qpr&3##@rizf)mo^Z z!BlM@u;Mmd2l7HAS$a8{*( zuEzwysQDRKSVD}1Mr3&L{1{iF0K<6*(_uvYn$jf?Y;y8A<185rcsff3ikaS+O7yl| zqGBr1D_{NtR==V|KT?U_K%yh^C?tA>?h=Wde^8=6`It&{!CCTAq6_2+P6&c2*d`PQ z&ZJDRX%@QTio)K${sVLFt$xlxcriNApVQG3{RQ77HN-~p z&Xf~kD;~a&=y5e67q{e@ZyyG1AJ57FDV`uM&ged$(&UVa9j2pP31^5%qLODoKTc2K zR6k(KBU4F0^(UkkaH`_foAT8?ChRYZ_n*pBffPvzHs=bdl1;Kjw#g1D0n=0E7DlJ!&^pUCu2Lb8@CBq z2`FxpasiE3Dz8X+@iK4;<#Lg0Zss$>UBE5MCFDZT1s2Myl3u(!Tt>Q*AziM{{1x4? zIHS&8r@Xl$3yW8d%UIaT#f;GWR0|Lp`qqcg&9R|_Z2BFUWYEBSSid0 zq99rli9zUh2PGA3fYK|)RWrfj-Rd$9N=sEeCv~|rGdAQZU<1=qK}5l-{4Cz+F5{=1 zRbO8 z^;O9&UX?E+x1A#=l1piBGep0dOED<;%5JuJ{l0{gYT-*0r~J$_P+eISi#Pep7$|+k zKygBs?=rj!Se5$X*8{Y9d#qS!HQLKL9X4$k>;W=%S zRF_3ooA^-qwTVOZk^Eh*J(b%;{;n8dsD3w0hL`_N-~+ru;D9k3!waX#upIspD2DOs z;y4^*q3j0uW(J;wu45XE;@H;W7<~`jAfhm^y*SXN)B@yj&#P^Fh zSj-IijQSIvK}`#T9`%CA;jDq~7KTEDF&c?g8C8h4hK}FEv5XpG)24VQf}jVCXr z0+(uZ@{Nm1A{qq=qc!o`2>|>;5S7SpUXPicUWMTud=u;rDpFDqO&_E58WC5i{6ax_ ziU@1tD?ey8i<;oqZ8*hv^dCS+{Rz5+>T5;Pq5LZr7(QlCQCneZ9lQxYALxjWOgMQE zW%dxo;Pm`aII$58fj9oqgP)Ek{LwaI8??&1LGT)<->rD~W*BD${E>$(iFrQ?-~jIP ZZcL*-jXL;RJ092n_!qPosohg50064nxvT&H literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/entry/app.DRELdRUq.js.br b/apps/dashboard/build/_app/immutable/entry/app.DRELdRUq.js.br deleted file mode 100644 index 778cf10835aaf4606915bc33807c4aa3cfb2a9d5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3563 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 OpxIl60Vg<6l12xAdoINQ literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.gz b/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..70f2eaad12ee1ccdb779d62c8fae0e32c45a3ac0 GIT binary patch literal 107 zcmb2|=3oE;CgIa(bWiAOt@I1=&5?5vOsAaf!{>1zZz2 UUNuHoEEk%+l?3c?pt2gB0R|v7SO5S3 diff --git a/apps/dashboard/build/_app/immutable/entry/start.DfC8txIX.js.gz b/apps/dashboard/build/_app/immutable/entry/start.DfC8txIX.js.gz deleted file mode 100644 index 90eac39f00d7137925d31f6a1ce1111f0dfaa06a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 107 zcmb2|=3oE;CgIa(bWiAOt@I1=&{const r=_t;return{page:{subscribe:r.page.subscribe},navigating:{subscribe:r.navigating.subscribe},updated:r.updated}},Et={subscribe(r){return Mt().page.subscribe(r)}};var Tt=x('
');function St(r){const i=()=>se(lt,"$suppressedCount",o),[o,n]=Ve();var g=Ze(),C=ce(g);{var y=N=>{var $=Tt(),w=s(a($),2),p=a(w);t(w),t($),B(()=>h(p,`Actively forgetting ${i()??""} ${i()===1?"memory":"memories"}`)),u(N,$)};q(C,N=>{i()>0&&N(y)})}u(r,g),n()}var jt=x(''),Dt=x('
');function It(r,i){Ke(i,!1);const o=()=>se(Te,"$toasts",n),[n,g]=Ve(),C={DreamCompleted:"✦",ConsolidationCompleted:"◉",ConnectionDiscovered:"⟷",MemoryPromoted:"↑",MemoryDemoted:"↓",MemorySuppressed:"◬",MemoryUnsuppressed:"◉",Rac1CascadeSwept:"✺",MemoryDeleted:"✕",HookVerdictRecorded:"⚑"};function y(p){return C[p]??"◆"}function N(p){Te.dismiss(p.id)}function $(p,d){(p.key==="Enter"||p.key===" ")&&(p.preventDefault(),Te.dismiss(d.id))}At();var w=Dt();Se(w,5,o,p=>p.id,(p,d)=>{var M=jt(),R=s(a(M),2),V=a(R),Y=a(V),ee=a(Y,!0);t(Y);var Q=s(Y,2),re=a(Q,!0);t(Q),t(V);var v=s(V,2),m=a(v,!0);t(v),t(R),_e(2),t(M),B(A=>{ke(M,"aria-label",`${e(d).title??""}: ${e(d).body??""}. Click to dismiss.`),ct(M,`--toast-color: ${e(d).color??""}; --toast-dwell: ${e(d).dwellMs??""}ms;`),h(ee,A),h(re,e(d).title),h(m,e(d).body)},[()=>y(e(d).type)]),J("click",M,()=>N(e(d))),J("keydown",M,A=>$(A,e(d))),Pe("mouseenter",M,()=>Te.pauseDwell(e(d).id,e(d).dwellMs)),Pe("mouseleave",M,()=>Te.resumeDwell(e(d).id)),Pe("focus",M,()=>Te.pauseDwell(e(d).id,e(d).dwellMs)),Pe("blur",M,()=>Te.resumeDwell(e(d).id)),u(p,M)}),t(w),u(r,w),He(),g()}Ge(["click","keydown"]);function Ne(r){const i=r.data;if(!i||typeof i!="object")return null;const o=i.timestamp??i.at??i.occurred_at;if(o==null)return null;if(typeof o=="number")return Number.isFinite(o)?o>1e12?o:o*1e3:null;if(typeof o!="string")return null;const n=Date.parse(o);return Number.isFinite(n)?n:null}const Qe=10,ut=3e4,Ft=Qe*ut;function Nt(r,i){const o=i-Ft,n=new Array(Qe).fill(0);for(const C of r){if(C.type==="Heartbeat")continue;const y=Ne(C);if(y===null||yi)continue;const N=Math.min(Qe-1,Math.floor((y-o)/ut));n[N]+=1}const g=Math.max(1,...n);return n.map(C=>({count:C,ratio:C/g}))}function Lt(r,i){const o=i-864e5;for(const n of r){if(n.type!=="DreamCompleted")continue;return(Ne(n)??i)>=o?n:null}return null}function Bt(r){if(!r||!r.data)return null;const i=r.data,o=typeof i.insights_generated=="number"?i.insights_generated:typeof i.insightsGenerated=="number"?i.insightsGenerated:null;return o!==null&&Number.isFinite(o)?o:null}function Rt(r,i){let o=null,n=null;for(const N of r)if(!o&&N.type==="DreamStarted"&&(o=N),!n&&N.type==="DreamCompleted"&&(n=N),o&&n)break;if(!o)return!1;const g=Ne(o)??i,C=i-300*1e3;return g=n}return!1}var Ot=x(' at risk',1),Kt=x('0 at risk',1),Ht=x('— at risk',1),Gt=x(' intentions',1),Wt=x('— intentions'),qt=x('· insights',1),zt=x('✦ Last dream: ',1),Yt=x('No recent dream'),Qt=x('
'),Ut=x('
DREAMING...
',1),Xt=x(''),Zt=x('
memories · avg retention
');function Jt(r,i){Ke(i,!0);const o=()=>se(dt,"$avgRetention",C),n=()=>se(kt,"$eventFeed",C),g=()=>se(ot,"$memoryCount",C),[C,y]=Ve(),N=G(()=>Math.round((o()??0)*100)),$=G(()=>(o()??0)>=.5);let w=ie(null);async function p(){try{const l=await Oe.retentionDistribution();if(Array.isArray(l.endangered)&&l.endangered.length>0){k(w,l.endangered.length,!0);return}const c=l.distribution??[];let j=0;for(const _ of c){const D=/^(\d+)/.exec(_.range);if(!D)continue;const F=Number.parseInt(D[1],10);Number.isFinite(F)&&F<30&&(j+=_.count??0)}k(w,j,!0)}catch{k(w,null)}}let d=ie(null);async function M(){var l;try{const c=await Oe.intentions("active");k(d,c.total??((l=c.intentions)==null?void 0:l.length)??0,!0)}catch{k(d,null)}}let R=ie(ht(Date.now()));const V=G(()=>{const l=n(),c=Lt(l,e(R)),j=c?Ne(c)??e(R):null,_=j!==null?e(R)-j:null;return{isDreaming:Rt(l,e(R)),recent:c,recentMsAgo:_,insights:Bt(c)}}),Y=G(()=>Nt(n(),e(R))),ee=G(()=>Pt(n(),e(R)));Xe(()=>{p(),M();const l=setInterval(()=>{k(R,Date.now(),!0)},1e3),c=setInterval(()=>{p(),M()},6e4);return()=>{clearInterval(l),clearInterval(c)}});var Q=Zt();let re;var v=a(Q),m=a(v),A=a(m);let ye;var Ae=s(A,2);let je;t(m);var ve=s(m,2),T=a(ve,!0);t(ve);var E=s(ve,6);let b;var X=a(E);t(E),_e(2),t(v);var W=s(v,4),K=a(W);{var le=l=>{var c=Ot(),j=ce(c),_=a(j,!0);t(j),_e(2),B(()=>h(_,e(w))),u(l,c)},S=l=>{var c=Kt();_e(2),u(l,c)},I=l=>{var c=Ht();_e(2),u(l,c)};q(K,l=>{e(w)!==null&&e(w)>0?l(le):e(w)===0?l(S,1):l(I,!1)})}t(W);var f=s(W,4),O=a(f);{var z=l=>{var c=Gt(),j=ce(c);let _;var D=s(j,2);let F;var H=a(D,!0);t(D),_e(2),B(()=>{_=U(j,1,"inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,_,{"bg-node-pattern":e(d)>5,"animate-ping-slow":e(d)>5,"bg-muted":e(d)<=5}),F=U(D,1,"tabular-nums svelte-1kk3799",null,F,{"text-node-pattern":e(d)>5,"text-text":e(d)>0&&e(d)<=5,"text-muted":e(d)===0}),h(H,e(d))}),u(l,c)},pe=l=>{var c=Wt();u(l,c)};q(O,l=>{e(d)!==null?l(z):l(pe,!1)})}t(f);var te=s(f,4),oe=a(te);{var ue=l=>{var c=zt(),j=s(ce(c),4),_=a(j,!0);t(j);var D=s(j,2);{var F=H=>{var ne=qt(),Me=s(ce(ne),2),we=a(Me,!0);t(Me),_e(2),B(()=>h(we,e(V).insights)),u(H,ne)};q(D,H=>{e(V).insights!==null&&H(F)})}B(H=>h(_,H),[()=>Vt(e(V).recentMsAgo)]),u(l,c)},ae=l=>{var c=Yt();u(l,c)};q(oe,l=>{e(V).recent&&e(V).recentMsAgo!==null?l(ue):l(ae,!1)})}t(te);var de=s(te,4),me=s(a(de),2);Se(me,21,()=>e(Y),Fe,(l,c)=>{var j=Qt();B(_=>ct(j,`height: ${_??""}%; opacity: ${e(c).count===0?.18:.5+e(c).ratio*.5};`),[()=>Math.max(10,e(c).ratio*100)]),u(l,j)}),t(me),t(de);var Ce=s(de,2);{var Be=l=>{var c=Ut();_e(2),u(l,c)};q(Ce,l=>{e(V).isDreaming&&l(Be)})}var De=s(Ce,4);{var Re=l=>{var c=Xt();u(l,c)};q(De,l=>{e(ee)&&l(Re)})}t(Q),B(()=>{re=U(Q,1,"ambient-strip relative flex h-9 w-full items-center gap-0 overflow-hidden border-b border-synapse/15 bg-black/40 px-3 text-[11px] text-dim backdrop-blur-md svelte-1kk3799",null,re,{"ambient-flash":e(ee)}),ye=U(A,1,"absolute inline-flex h-full w-full animate-ping rounded-full opacity-75 svelte-1kk3799",null,ye,{"bg-recall":e($),"bg-warning":!e($)}),je=U(Ae,1,"relative inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,je,{"bg-recall":e($),"bg-warning":!e($)}),h(T,g()),b=U(E,1,"svelte-1kk3799",null,b,{"text-recall":e($),"text-warning":!e($)}),h(X,`${e(N)??""}%`)}),u(r,Q),He(),y()}var ea=x(" "),ta=x('
    • '),aa=x(' ',1),sa=x('

    Appeal recorded.

    '),ra=x('

    No appealable veto in this receipt.

    '),na=x('
    Claim

    Verdict

    Precedent
      Fix

      Appeal
      '),ia=x('
      ');function la(r,i){Ke(i,!0);const o=["PASS","NOTE","CAUTION","VETO","APPEALED"];let n=ie(null),g=ie(""),C=ie(!1),y=ie(null),N=ie(null),$=G(()=>{var v;return((v=e(n))==null?void 0:v.verdictBar)??(e(g)?"CAUTION":"NOTE")}),w=G(()=>{var v,m;return((v=e(n))==null?void 0:v.claims.find(A=>A.decision==="veto"))??((m=e(n))==null?void 0:m.claims.find(A=>A.decision==="appealed"))??null}),p=G(()=>{var v;return e(w)??((v=e(n))==null?void 0:v.claims[0])??null}),d=G(()=>!!e(n)||!!e(g));Xe(()=>{M();const v=window.setInterval(M,4e3);return()=>window.clearInterval(v)});async function M(){var v;try{const m=await Oe.sanhedrin.latest();k(n,m.receipt,!0),k(g,""),((v=m.receipt)==null?void 0:v.verdictBar)==="VETO"&&m.receipt.id!==e(N)&&(k(C,!0),k(N,m.receipt.id,!0))}catch(m){k(g,m instanceof Error?m.message:String(m),!0)}}async function R(v){var m;if(!(!e(w)||((m=e(n))==null?void 0:m.verdictBar)!=="VETO")){k(y,v,!0);try{const A=await Oe.sanhedrin.appeal(v,void 0,e(w).id,e(n).id);k(n,A.receipt,!0),k(C,!0),k(g,"")}catch(A){k(g,A instanceof Error?A.message:String(A),!0)}finally{k(y,null)}}}function V(v){if(!v)return"";const m=new Date(v);return Number.isNaN(m.getTime())?"":m.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"})}function Y(v){var m;return(m=v==null?void 0:v.precedent)!=null&&m.length?v.precedent.map(A=>A.summary??A.command??"Precedent recorded.").slice(0,3):["No precedent attached."]}var ee=Ze(),Q=ce(ee);{var re=v=>{var m=ia(),A=a(m),ye=s(a(A),2);Se(ye,21,()=>o,Fe,(S,I)=>{var f=ea();let O;var z=a(f,!0);t(f),B(()=>{ke(f,"aria-current",e(I)===e($)?"true":void 0),O=U(f,1,"svelte-1j425e6",null,O,{active:e(I)===e($)}),h(z,e(I))}),u(S,f)}),t(ye);var Ae=s(ye,2),je=a(Ae);t(Ae);var ve=s(Ae,2),T=a(ve);{var E=S=>{var I=et();B(()=>h(I,e(g))),u(S,I)},b=S=>{var I=et();B(()=>h(I,e(n).summary)),u(S,I)};q(T,S=>{e(g)?S(E):e(n)&&S(b,1)})}t(ve);var X=s(ve,2),W=a(X,!0);t(X),t(A);var K=s(A,2);{var le=S=>{var I=na(),f=a(I),O=a(f),z=s(a(O),2),pe=a(z,!0);t(z),t(O);var te=s(O,2),oe=s(a(te),2),ue=a(oe);t(oe),t(te);var ae=s(te,2),de=s(a(ae),2);Se(de,21,()=>Y(e(p)),Fe,(_,D)=>{var F=ta(),H=a(F,!0);t(F),B(()=>h(H,e(D))),u(_,F)}),t(de),t(ae);var me=s(ae,2),Ce=s(a(me),2),Be=a(Ce,!0);t(Ce),t(me),t(f);var De=s(f,2),Re=s(a(De),2);{var l=_=>{var D=aa(),F=ce(D),H=a(F,!0);t(F);var ne=s(F,2),Me=a(ne,!0);t(ne);var we=s(ne,2),We=a(we,!0);t(we),B((L,P,fe)=>{F.disabled=L,h(H,e(y)==="stale"?"Saving":"Stale"),ne.disabled=P,h(Me,e(y)==="wrong"?"Saving":"Wrong"),we.disabled=fe,h(We,e(y)==="too_strict"?"Saving":"Too strict")},[()=>!!e(y),()=>!!e(y),()=>!!e(y)]),J("click",F,()=>R("stale")),J("click",ne,()=>R("wrong")),J("click",we,()=>R("too_strict")),u(_,D)},c=_=>{var D=sa();u(_,D)},j=_=>{var D=ra();u(_,D)};q(Re,_=>{e(w)&&e(n).verdictBar==="VETO"?_(l):e(n).verdictBar==="APPEALED"?_(c,1):_(j,!1)})}t(De),t(I),B(()=>{var _,D,F,H;h(pe,((_=e(p))==null?void 0:_.text)??e(n).draftPreview),h(ue,`${((D=e(p))==null?void 0:D.decision)??e(n).overall??""} · ${((F=e(p))==null?void 0:F.evidence_state)??e($)??""}`),h(Be,((H=e(p))==null?void 0:H.fix)||"No change required.")}),u(S,I)};q(K,S=>{e(C)&&e(n)&&S(le)})}t(m),B((S,I)=>{U(m,1,S,"svelte-1j425e6"),ke(A,"aria-expanded",e(C)),h(je,`Current verdict: ${e($)??""}`),h(W,I)},[()=>`verdict-bar tone-${e($).toLowerCase()}`,()=>{var S;return V((S=e(n))==null?void 0:S.createdAt)}]),J("click",A,()=>k(C,!e(C))),u(v,m)};q(Q,v=>{e(d)&&v(re)})}u(r,ee),He()}Ge(["click"]);const mt="vestige.theme",rt="vestige-theme-light",Le=vt("dark"),Ue=vt(!0),nt=Ct([Le,Ue],([r,i])=>r==="auto"?i?"dark":"light":r);function oa(r){return r==="dark"||r==="light"||r==="auto"}function da(r){if(oa(r)){Le.set(r);try{localStorage.setItem(mt,r)}catch{}}}function Ye(){const r=pt(Le);da(r==="dark"?"light":r==="light"?"auto":"dark")}function ca(){if(document.getElementById(rt))return;const r=document.createElement("style");r.id=rt,r.textContent=` +/* Vestige light-mode overrides — injected by theme.ts. + * Activated by [data-theme='light'] on . + * Tokens mirror the real names used in app.css so the cascade stays clean. */ +[data-theme='light'] { + /* Core surface palette (slate scale) */ + --color-void: #f8fafc; /* slate-50 — page background */ + --color-abyss: #f1f5f9; /* slate-100 */ + --color-deep: #e2e8f0; /* slate-200 */ + --color-surface: #f1f5f9; /* slate-100 */ + --color-elevated: #e2e8f0; /* slate-200 */ + --color-subtle: #cbd5e1; /* slate-300 */ + --color-muted: #94a3b8; /* slate-400 */ + --color-dim: #475569; /* slate-600 */ + --color-text: #0f172a; /* slate-900 */ + --color-bright: #020617; /* slate-950 */ +} + +/* Baseline body/html wiring — app.css sets these against the dark + * tokens; we just let the variables do the work. Reassert for clarity. */ +[data-theme='light'] html, +html[data-theme='light'] { + background: var(--color-void); + color: var(--color-text); +} + +/* Glass surfaces — recompose on a light canvas. The original alphas + * are tuned for dark; invert-and-tint for light so panels still read + * as elevated instead of vanishing. */ +[data-theme='light'] .glass { + background: rgba(255, 255, 255, 0.65); + border: 1px solid rgba(99, 102, 241, 0.12); + box-shadow: + inset 0 1px 0 0 rgba(255, 255, 255, 0.6), + 0 4px 24px rgba(15, 23, 42, 0.08); +} +[data-theme='light'] .glass-subtle { + background: rgba(255, 255, 255, 0.55); + border: 1px solid rgba(99, 102, 241, 0.1); + box-shadow: + inset 0 1px 0 0 rgba(255, 255, 255, 0.5), + 0 2px 12px rgba(15, 23, 42, 0.06); +} +[data-theme='light'] .glass-sidebar { + background: rgba(248, 250, 252, 0.82); + border-right: 1px solid rgba(99, 102, 241, 0.14); + box-shadow: + inset -1px 0 0 0 rgba(255, 255, 255, 0.4), + 4px 0 24px rgba(15, 23, 42, 0.08); +} +[data-theme='light'] .glass-panel { + background: rgba(255, 255, 255, 0.75); + border: 1px solid rgba(99, 102, 241, 0.14); + box-shadow: + inset 0 1px 0 0 rgba(255, 255, 255, 0.5), + 0 8px 32px rgba(15, 23, 42, 0.1); +} + +/* Halve glow intensity — neon accents stay recognizable without + * washing out on slate-50. */ +[data-theme='light'] .glow-synapse { + box-shadow: 0 0 10px rgba(99, 102, 241, 0.15), 0 0 30px rgba(99, 102, 241, 0.05); +} +[data-theme='light'] .glow-dream { + box-shadow: 0 0 10px rgba(168, 85, 247, 0.15), 0 0 30px rgba(168, 85, 247, 0.05); +} +[data-theme='light'] .glow-memory { + box-shadow: 0 0 10px rgba(59, 130, 246, 0.15), 0 0 30px rgba(59, 130, 246, 0.05); +} + +/* Ambient orbs are gorgeous on black and blinding on white. Tame them. */ +[data-theme='light'] .ambient-orb { + opacity: 0.18; + filter: blur(100px); +} + +/* Scrollbar recolor for the lighter surface. */ +[data-theme='light'] ::-webkit-scrollbar-thumb { + background: #cbd5e1; +} +[data-theme='light'] ::-webkit-scrollbar-thumb:hover { + background: #94a3b8; +} +`,document.head.appendChild(r)}function it(r){document.documentElement.dataset.theme=r}let ge=null,$e=null,be=null,xe=null;function va(){ge&&$e&&ge.removeEventListener("change",$e),xe==null||xe(),be==null||be(),ge=null,$e=null,xe=null,be=null,ca();let r="dark";try{const i=localStorage.getItem(mt);(i==="dark"||i==="light"||i==="auto")&&(r=i)}catch{}return Le.set(r),ge=window.matchMedia("(prefers-color-scheme: dark)"),Ue.set(ge.matches),$e=i=>Ue.set(i.matches),ge.addEventListener("change",$e),it(pt(nt)),xe=nt.subscribe(it),be=Le.subscribe(()=>{}),()=>{ge&&$e&&ge.removeEventListener("change",$e),ge=null,$e=null,xe==null||xe(),be==null||be(),xe=null,be=null}}var pa=x('');function ua(r){const i=()=>se(Le,"$theme",o),[o,n]=Ve(),g={dark:"Dark",light:"Light",auto:"Auto (system)"},C={dark:"light",light:"auto",auto:"dark"};let y=G(i),N=G(()=>C[e(y)]),$=G(()=>`Toggle theme: ${g[e(y)]} (click for ${g[e(N)]})`);var w=pa(),p=a(w),d=a(p);let M;var R=s(d,2);let V;var Y=s(R,2);let ee;t(p),t(w),B(()=>{ke(w,"aria-label",e($)),ke(w,"title",e($)),ke(w,"data-mode",e(y)),M=U(d,0,"icon svelte-1cmi4dh",null,M,{active:e(y)==="dark"}),V=U(R,0,"icon svelte-1cmi4dh",null,V,{active:e(y)==="light"}),ee=U(Y,0,"icon svelte-1cmi4dh",null,ee,{active:e(y)==="auto"})}),J("click",w,function(...Q){Ye==null||Ye.apply(this,Q)}),u(r,w),n()}Ge(["click"]);var ma=x('       '),fa=x('
      '),ha=x(''),ga=x(' '),ba=x('
      ',1),xa=x(''),_a=x('
      No matches
      '),ka=x('
      ◎ esc
      '),ya=x(" ",1);function Ga(r,i){Ke(i,!0);const o=()=>se(Et,"$page",$),n=()=>se(wt,"$isConnected",$),g=()=>se(ot,"$memoryCount",$),C=()=>se(dt,"$avgRetention",$),y=()=>se(yt,"$uptimeSeconds",$),N=()=>se(lt,"$suppressedCount",$),[$,w]=Ve();let p=ie(!1),d=ie(""),M=ie(void 0),R=G(()=>o().url.pathname.startsWith(he)?o().url.pathname.slice(he.length)||"/":o().url.pathname),V=G(()=>e(R)==="/waitlist"||e(R).startsWith("/waitlist/"));Xe(()=>{e(V)||st.connect();const T=va();function E(b){if(e(V))return;if((b.metaKey||b.ctrlKey)&&b.key==="k"){b.preventDefault(),k(p,!e(p)),k(d,""),e(p)&&requestAnimationFrame(()=>{var K;return(K=e(M))==null?void 0:K.focus()});return}if(b.key==="Escape"&&e(p)){k(p,!1);return}if(b.target instanceof HTMLInputElement||b.target instanceof HTMLTextAreaElement)return;if(b.key==="/"){b.preventDefault();const K=document.querySelector('input[type="text"]');K==null||K.focus();return}const W={g:"/graph",m:"/memories",t:"/timeline",f:"/feed",e:"/explore",i:"/intentions",s:"/stats",r:"/reasoning",a:"/activation",d:"/dreams",c:"/schedule",p:"/importance",u:"/duplicates",x:"/contradictions",n:"/patterns"}[b.key.toLowerCase()];W&&!b.metaKey&&!b.ctrlKey&&!b.altKey&&(b.preventDefault(),at(`${he}${W}`))}return window.addEventListener("keydown",E),()=>{st.disconnect(),window.removeEventListener("keydown",E),T()}});const Y=[{href:"/graph",label:"Graph",icon:"◎",shortcut:"G"},{href:"/reasoning",label:"Reasoning",icon:"✦",shortcut:"R"},{href:"/memories",label:"Memories",icon:"◈",shortcut:"M"},{href:"/timeline",label:"Timeline",icon:"◷",shortcut:"T"},{href:"/feed",label:"Feed",icon:"◉",shortcut:"F"},{href:"/explore",label:"Explore",icon:"◬",shortcut:"E"},{href:"/activation",label:"Activation",icon:"◈",shortcut:"A"},{href:"/dreams",label:"Dreams",icon:"✧",shortcut:"D"},{href:"/schedule",label:"Schedule",icon:"◷",shortcut:"C"},{href:"/importance",label:"Importance",icon:"◎",shortcut:"P"},{href:"/duplicates",label:"Duplicates",icon:"◉",shortcut:"U"},{href:"/contradictions",label:"Contradictions",icon:"⚠",shortcut:"X"},{href:"/patterns",label:"Patterns",icon:"▦",shortcut:"N"},{href:"/intentions",label:"Intentions",icon:"◇",shortcut:"I"},{href:"/stats",label:"Stats",icon:"◫",shortcut:"S"},{href:"/settings",label:"Settings",icon:"⚙",shortcut:","}],ee=Y.slice(0,5);function Q(T,E){const b=E.startsWith(he)?E.slice(he.length)||"/":E;return T==="/graph"?b==="/"||b==="/graph":b.startsWith(T)}let re=G(()=>e(d)?Y.filter(T=>T.label.toLowerCase().includes(e(d).toLowerCase())):Y);function v(T){k(p,!1),k(d,""),at(`${he}${T}`)}var m=ya(),A=ce(m);{var ye=T=>{var E=Ze(),b=ce(E);tt(b,()=>i.children),u(T,E)},Ae=T=>{var E=ba(),b=s(ce(E),6),X=a(b),W=a(X),K=s(W,2);Se(K,21,()=>Y,Fe,(L,P)=>{const fe=G(()=>Q(e(P).href,o().url.pathname));var Z=ma(),Ee=a(Z),qe=a(Ee,!0);t(Ee);var Ie=s(Ee,2),ze=a(Ie,!0);t(Ie);var Je=s(Ie,2),ft=a(Je,!0);t(Je),t(Z),B(()=>{ke(Z,"href",`${he??""}${e(P).href??""}`),U(Z,1,`flex items-center gap-3 px-3 py-2.5 rounded-lg transition-all duration-200 text-sm + ${e(fe)?"bg-synapse/15 text-synapse-glow border border-synapse/30 shadow-[0_0_12px_rgba(99,102,241,0.15)] nav-active-border":"text-dim hover:text-text hover:bg-white/[0.03] border border-transparent"}`),h(qe,e(P).icon),h(ze,e(P).label),h(ft,e(P).shortcut)}),u(L,Z)}),t(K);var le=s(K,2),S=a(le);t(le);var I=s(le,2),f=a(I),O=a(f),z=s(O,2),pe=a(z,!0);t(z);var te=s(z,2),oe=a(te);ua(oe),t(te),t(f);var ue=s(f,2),ae=a(ue),de=a(ae);t(ae);var me=s(ae,2),Ce=a(me);t(me);var Be=s(me,2);{var De=L=>{var P=fa(),fe=a(P);t(P),B(Z=>h(fe,`up ${Z??""}`),[()=>$t(y())]),u(L,P)};q(Be,L=>{y()>0&&L(De)})}t(ue);var Re=s(ue,2);{var l=L=>{var P=ha(),fe=a(P);St(fe),t(P),u(L,P)};q(Re,L=>{N()>0&&L(l)})}t(I),t(X);var c=s(X,2),j=a(c);Jt(j,{});var _=s(j,2);la(_,{});var D=s(_,2),F=a(D);tt(F,()=>i.children),t(D),t(c);var H=s(c,2),ne=a(H),Me=a(ne);Se(Me,17,()=>ee,Fe,(L,P)=>{const fe=G(()=>Q(e(P).href,o().url.pathname));var Z=ga(),Ee=a(Z),qe=a(Ee,!0);t(Ee);var Ie=s(Ee,2),ze=a(Ie,!0);t(Ie),t(Z),B(()=>{ke(Z,"href",`${he??""}${e(P).href??""}`),U(Z,1,`flex flex-col items-center gap-0.5 px-3 py-2 rounded-lg transition-all min-w-[3.5rem] + ${e(fe)?"text-synapse-glow":"text-muted"}`),h(qe,e(P).icon),h(ze,e(P).label)}),u(L,Z)});var we=s(Me,2);t(ne),t(H),t(b);var We=s(b,2);It(We,{}),B(L=>{ke(W,"href",`${he??""}/graph`),U(O,1,`w-2 h-2 rounded-full ${n()?"bg-recall animate-pulse-glow":"bg-decay"}`),h(pe,n()?"Connected":"Offline"),h(de,`${g()??""} memories`),h(Ce,`${L??""}% retention`)},[()=>(C()*100).toFixed(0)]),J("click",S,()=>{k(p,!0),k(d,""),requestAnimationFrame(()=>{var L;return(L=e(M))==null?void 0:L.focus()})}),J("click",we,()=>{k(p,!0),k(d,""),requestAnimationFrame(()=>{var L;return(L=e(M))==null?void 0:L.focus()})}),u(T,E)};q(A,T=>{e(V)?T(ye):T(Ae,!1)})}var je=s(A,2);{var ve=T=>{var E=ka(),b=a(E),X=a(b),W=s(a(X),2);gt(W),xt(W,f=>k(M,f),()=>e(M)),_e(2),t(X);var K=s(X,2),le=a(K);Se(le,17,()=>e(re),Fe,(f,O)=>{var z=xa(),pe=a(z),te=a(pe,!0);t(pe);var oe=s(pe,2),ue=a(oe,!0);t(oe);var ae=s(oe,2),de=a(ae,!0);t(ae),t(z),B(()=>{h(te,e(O).icon),h(ue,e(O).label),h(de,e(O).shortcut)}),J("click",z,()=>v(e(O).href)),u(f,z)});var S=s(le,2);{var I=f=>{var O=_a();u(f,O)};q(S,f=>{e(re).length===0&&f(I)})}t(K),t(b),t(E),J("keydown",E,f=>{f.key==="Escape"&&k(p,!1)}),J("click",E,f=>{f.target===f.currentTarget&&k(p,!1)}),J("keydown",W,f=>{f.key==="Enter"&&e(re).length>0&&v(e(re)[0].href)}),bt(W,()=>e(d),f=>k(d,f)),u(T,E)};q(je,T=>{e(p)&&!e(V)&&T(ve)})}u(r,m),He(),w()}Ge(["click","keydown"]);export{Ga as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.br b/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.br new file mode 100644 index 0000000000000000000000000000000000000000..91dae85c22fe054d71781ce4958e9107cebe375a GIT binary patch literal 9644 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 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.gz b/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..524ab3b4cbb4f45c412a3343451d28da4008fd0b GIT binary patch literal 10974 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 M0c3Y|UYmLV0MEgV&;S4c literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js b/apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js deleted file mode 100644 index ba2f3b5..0000000 --- a/apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js +++ /dev/null @@ -1,86 +0,0 @@ -import"../chunks/Bzak7iHL.js";import{o as st}from"../chunks/GG5zm9kr.js";import{f as ce,e as o,d as s,r as t,t as N,p as We,n as se,g as e,a as Oe,s as ye,c as mt,h as A,u as j}from"../chunks/CpWkWWOo.js";import{s as _,d as Ye,a as re,e as Le}from"../chunks/BlVfL1ME.js";import{i as B}from"../chunks/B4yTwGkE.js";import{e as De,i as Ne}from"../chunks/CGEBXrjl.js";import{c as rt,a as u,f as m}from"../chunks/CHOnp4oo.js";import{s as Xe}from"../chunks/CJCPY1OL.js";import{s as be,r as ft}from"../chunks/A7po6GxK.js";import{s as G}from"../chunks/aVbAZ-t7.js";import{b as ht}from"../chunks/sZcqyNBA.js";import{b as gt}from"../chunks/CJsMJEun.js";import{a as H,s as Te}from"../chunks/C6HuKgyx.js";import{s as bt,g as Ze}from"../chunks/BTwePnbx.js";import{b as U}from"../chunks/BdslOLCg.js";import{s as nt,m as it,a as ot,e as xt,w as Je,u as kt,i as _t,f as yt}from"../chunks/MAY1QfFZ.js";import{i as wt}from"../chunks/BUoSzNdg.js";import{s as lt}from"../chunks/Cx-f-Pzo.js";import{t as ge}from"../chunks/BjdL4Pm2.js";import{a as Ue}from"../chunks/DNjM5a-l.js";import{d as $t,w as dt,g as ct}from"../chunks/BeMFXnHE.js";const Mt=()=>{const a=bt;return{page:{subscribe:a.page.subscribe},navigating:{subscribe:a.navigating.subscribe},updated:a.updated}},Ct={subscribe(a){return Mt().page.subscribe(a)}};var At=m('
      ');function Dt(a){const r=()=>H(nt,"$suppressedCount",i),[i,c]=Te();var f=rt(),M=ce(f);{var y=D=>{var x=At(),h=o(s(x),2),v=s(h);t(h),t(x),N(()=>_(v,`Actively forgetting ${r()??""} ${r()===1?"memory":"memories"}`)),u(D,x)};B(M,D=>{r()>0&&D(y)})}u(a,f),c()}var Tt=m(''),Et=m('
      ');function Ft(a,r){We(r,!1);const i=()=>H(ge,"$toasts",c),[c,f]=Te(),M={DreamCompleted:"✦",ConsolidationCompleted:"◉",ConnectionDiscovered:"⟷",MemoryPromoted:"↑",MemoryDemoted:"↓",MemorySuppressed:"◬",MemoryUnsuppressed:"◉",Rac1CascadeSwept:"✺",MemoryDeleted:"✕"};function y(v){return M[v]??"◆"}function D(v){ge.dismiss(v.id)}function x(v,l){(v.key==="Enter"||v.key===" ")&&(v.preventDefault(),ge.dismiss(l.id))}wt();var h=Et();De(h,5,i,v=>v.id,(v,l)=>{var b=Tt(),F=o(s(b),2),T=s(F),K=s(T),Q=s(K,!0);t(K);var V=o(K,2),X=s(V,!0);t(V),t(T);var Z=o(T,2),ne=s(Z,!0);t(Z),t(F),se(2),t(b),N(J=>{be(b,"aria-label",`${e(l).title??""}: ${e(l).body??""}. Click to dismiss.`),lt(b,`--toast-color: ${e(l).color??""}; --toast-dwell: ${e(l).dwellMs??""}ms;`),_(Q,J),_(X,e(l).title),_(ne,e(l).body)},[()=>y(e(l).type)]),re("click",b,()=>D(e(l))),re("keydown",b,J=>x(J,e(l))),Le("mouseenter",b,()=>ge.pauseDwell(e(l).id,e(l).dwellMs)),Le("mouseleave",b,()=>ge.resumeDwell(e(l).id)),Le("focus",b,()=>ge.pauseDwell(e(l).id,e(l).dwellMs)),Le("blur",b,()=>ge.resumeDwell(e(l).id)),u(v,b)}),t(h),u(a,h),Oe(),f()}Ye(["click","keydown"]);function we(a){const r=a.data;if(!r||typeof r!="object")return null;const i=r.timestamp??r.at??r.occurred_at;if(i==null)return null;if(typeof i=="number")return Number.isFinite(i)?i>1e12?i:i*1e3:null;if(typeof i!="string")return null;const c=Date.parse(i);return Number.isFinite(c)?c:null}const ze=10,vt=3e4,St=ze*vt;function It(a,r){const i=r-St,c=new Array(ze).fill(0);for(const M of a){if(M.type==="Heartbeat")continue;const y=we(M);if(y===null||yr)continue;const D=Math.min(ze-1,Math.floor((y-i)/vt));c[D]+=1}const f=Math.max(1,...c);return c.map(M=>({count:M,ratio:M/f}))}function Lt(a,r){const i=r-864e5;for(const c of a){if(c.type!=="DreamCompleted")continue;return(we(c)??r)>=i?c:null}return null}function Nt(a){if(!a||!a.data)return null;const r=a.data,i=typeof r.insights_generated=="number"?r.insights_generated:typeof r.insightsGenerated=="number"?r.insightsGenerated:null;return i!==null&&Number.isFinite(i)?i:null}function Rt(a,r){let i=null,c=null;for(const D of a)if(!i&&D.type==="DreamStarted"&&(i=D),!c&&D.type==="DreamCompleted"&&(c=D),i&&c)break;if(!i)return!1;const f=we(i)??r,M=r-300*1e3;return f=c}return!1}var Vt=m(' at risk',1),Bt=m('0 at risk',1),Gt=m('— at risk',1),Ht=m(' intentions',1),qt=m('— intentions'),zt=m('· insights',1),Pt=m('✦ Last dream: ',1),Wt=m('No recent dream'),Ot=m('
      '),Yt=m('
      DREAMING...
      ',1),Qt=m(''),Xt=m('
      memories · avg retention
      ');function Zt(a,r){We(r,!0);const i=()=>H(ot,"$avgRetention",M),c=()=>H(xt,"$eventFeed",M),f=()=>H(it,"$memoryCount",M),[M,y]=Te(),D=j(()=>Math.round((i()??0)*100)),x=j(()=>(i()??0)>=.5);let h=ye(null);async function v(){try{const n=await Ue.retentionDistribution();if(Array.isArray(n.endangered)&&n.endangered.length>0){A(h,n.endangered.length,!0);return}const d=n.distribution??[];let $=0;for(const S of d){const W=/^(\d+)/.exec(S.range);if(!W)continue;const O=Number.parseInt(W[1],10);Number.isFinite(O)&&O<30&&($+=S.count??0)}A(h,$,!0)}catch{A(h,null)}}let l=ye(null);async function b(){var n;try{const d=await Ue.intentions("active");A(l,d.total??((n=d.intentions)==null?void 0:n.length)??0,!0)}catch{A(l,null)}}let F=ye(mt(Date.now()));const T=j(()=>{const n=c(),d=Lt(n,e(F)),$=d?we(d)??e(F):null,S=$!==null?e(F)-$:null;return{isDreaming:Rt(n,e(F)),recent:d,recentMsAgo:S,insights:Nt(d)}}),K=j(()=>It(c(),e(F))),Q=j(()=>Kt(c(),e(F)));st(()=>{v(),b();const n=setInterval(()=>{A(F,Date.now(),!0)},1e3),d=setInterval(()=>{v(),b()},6e4);return()=>{clearInterval(n),clearInterval(d)}});var V=Xt();let X;var Z=s(V),ne=s(Z),J=s(ne);let Ee;var Re=o(J,2);let Fe;t(ne);var Me=o(ne,2),w=s(Me,!0);t(Me);var k=o(Me,6);let p;var z=s(k);t(k),se(2),t(Z);var L=o(Z,4),I=s(L);{var ie=n=>{var d=Vt(),$=ce(d),S=s($,!0);t($),se(2),N(()=>_(S,e(h))),u(n,d)},Ce=n=>{var d=Bt();se(2),u(n,d)},xe=n=>{var d=Gt();se(2),u(n,d)};B(I,n=>{e(h)!==null&&e(h)>0?n(ie):e(h)===0?n(Ce,1):n(xe,!1)})}t(L);var g=o(L,4),q=s(g);{var P=n=>{var d=Ht(),$=ce(d);let S;var W=o($,2);let O;var Y=s(W,!0);t(W),se(2),N(()=>{S=G($,1,"inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,S,{"bg-node-pattern":e(l)>5,"animate-ping-slow":e(l)>5,"bg-muted":e(l)<=5}),O=G(W,1,"tabular-nums svelte-1kk3799",null,O,{"text-node-pattern":e(l)>5,"text-text":e(l)>0&&e(l)<=5,"text-muted":e(l)===0}),_(Y,e(l))}),u(n,d)},ve=n=>{var d=qt();u(n,d)};B(q,n=>{e(l)!==null?n(P):n(ve,!1)})}t(g);var oe=o(g,4),pe=s(oe);{var ue=n=>{var d=Pt(),$=o(ce(d),4),S=s($,!0);t($);var W=o($,2);{var O=Y=>{var Ae=zt(),Ie=o(ce(Ae),2),Be=s(Ie,!0);t(Ie),se(2),N(()=>_(Be,e(T).insights)),u(Y,Ae)};B(W,Y=>{e(T).insights!==null&&Y(O)})}N(Y=>_(S,Y),[()=>jt(e(T).recentMsAgo)]),u(n,d)},le=n=>{var d=Wt();u(n,d)};B(pe,n=>{e(T).recent&&e(T).recentMsAgo!==null?n(ue):n(le,!1)})}t(oe);var me=o(oe,4),ke=o(s(me),2);De(ke,21,()=>e(K),Ne,(n,d)=>{var $=Ot();N(S=>lt($,`height: ${S??""}%; opacity: ${e(d).count===0?.18:.5+e(d).ratio*.5};`),[()=>Math.max(10,e(d).ratio*100)]),u(n,$)}),t(ke),t(me);var Se=o(me,2);{var je=n=>{var d=Yt();se(2),u(n,d)};B(Se,n=>{e(T).isDreaming&&n(je)})}var Ke=o(Se,4);{var Ve=n=>{var d=Qt();u(n,d)};B(Ke,n=>{e(Q)&&n(Ve)})}t(V),N(()=>{X=G(V,1,"ambient-strip relative flex h-9 w-full items-center gap-0 overflow-hidden border-b border-synapse/15 bg-black/40 px-3 text-[11px] text-dim backdrop-blur-md svelte-1kk3799",null,X,{"ambient-flash":e(Q)}),Ee=G(J,1,"absolute inline-flex h-full w-full animate-ping rounded-full opacity-75 svelte-1kk3799",null,Ee,{"bg-recall":e(x),"bg-warning":!e(x)}),Fe=G(Re,1,"relative inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,Fe,{"bg-recall":e(x),"bg-warning":!e(x)}),_(w,f()),p=G(k,1,"svelte-1kk3799",null,p,{"text-recall":e(x),"text-warning":!e(x)}),_(z,`${e(D)??""}%`)}),u(a,V),Oe(),y()}const pt="vestige.theme",et="vestige-theme-light",$e=dt("dark"),Pe=dt(!0),tt=$t([$e,Pe],([a,r])=>a==="auto"?r?"dark":"light":a);function Jt(a){return a==="dark"||a==="light"||a==="auto"}function Ut(a){if(Jt(a)){$e.set(a);try{localStorage.setItem(pt,a)}catch{}}}function qe(){const a=ct($e);Ut(a==="dark"?"light":a==="light"?"auto":"dark")}function ea(){if(document.getElementById(et))return;const a=document.createElement("style");a.id=et,a.textContent=` -/* Vestige light-mode overrides — injected by theme.ts. - * Activated by [data-theme='light'] on . - * Tokens mirror the real names used in app.css so the cascade stays clean. */ -[data-theme='light'] { - /* Core surface palette (slate scale) */ - --color-void: #f8fafc; /* slate-50 — page background */ - --color-abyss: #f1f5f9; /* slate-100 */ - --color-deep: #e2e8f0; /* slate-200 */ - --color-surface: #f1f5f9; /* slate-100 */ - --color-elevated: #e2e8f0; /* slate-200 */ - --color-subtle: #cbd5e1; /* slate-300 */ - --color-muted: #94a3b8; /* slate-400 */ - --color-dim: #475569; /* slate-600 */ - --color-text: #0f172a; /* slate-900 */ - --color-bright: #020617; /* slate-950 */ -} - -/* Baseline body/html wiring — app.css sets these against the dark - * tokens; we just let the variables do the work. Reassert for clarity. */ -[data-theme='light'] html, -html[data-theme='light'] { - background: var(--color-void); - color: var(--color-text); -} - -/* Glass surfaces — recompose on a light canvas. The original alphas - * are tuned for dark; invert-and-tint for light so panels still read - * as elevated instead of vanishing. */ -[data-theme='light'] .glass { - background: rgba(255, 255, 255, 0.65); - border: 1px solid rgba(99, 102, 241, 0.12); - box-shadow: - inset 0 1px 0 0 rgba(255, 255, 255, 0.6), - 0 4px 24px rgba(15, 23, 42, 0.08); -} -[data-theme='light'] .glass-subtle { - background: rgba(255, 255, 255, 0.55); - border: 1px solid rgba(99, 102, 241, 0.1); - box-shadow: - inset 0 1px 0 0 rgba(255, 255, 255, 0.5), - 0 2px 12px rgba(15, 23, 42, 0.06); -} -[data-theme='light'] .glass-sidebar { - background: rgba(248, 250, 252, 0.82); - border-right: 1px solid rgba(99, 102, 241, 0.14); - box-shadow: - inset -1px 0 0 0 rgba(255, 255, 255, 0.4), - 4px 0 24px rgba(15, 23, 42, 0.08); -} -[data-theme='light'] .glass-panel { - background: rgba(255, 255, 255, 0.75); - border: 1px solid rgba(99, 102, 241, 0.14); - box-shadow: - inset 0 1px 0 0 rgba(255, 255, 255, 0.5), - 0 8px 32px rgba(15, 23, 42, 0.1); -} - -/* Halve glow intensity — neon accents stay recognizable without - * washing out on slate-50. */ -[data-theme='light'] .glow-synapse { - box-shadow: 0 0 10px rgba(99, 102, 241, 0.15), 0 0 30px rgba(99, 102, 241, 0.05); -} -[data-theme='light'] .glow-dream { - box-shadow: 0 0 10px rgba(168, 85, 247, 0.15), 0 0 30px rgba(168, 85, 247, 0.05); -} -[data-theme='light'] .glow-memory { - box-shadow: 0 0 10px rgba(59, 130, 246, 0.15), 0 0 30px rgba(59, 130, 246, 0.05); -} - -/* Ambient orbs are gorgeous on black and blinding on white. Tame them. */ -[data-theme='light'] .ambient-orb { - opacity: 0.18; - filter: blur(100px); -} - -/* Scrollbar recolor for the lighter surface. */ -[data-theme='light'] ::-webkit-scrollbar-thumb { - background: #cbd5e1; -} -[data-theme='light'] ::-webkit-scrollbar-thumb:hover { - background: #94a3b8; -} -`,document.head.appendChild(a)}function at(a){document.documentElement.dataset.theme=a}let ee=null,de=null,te=null,ae=null;function ta(){ee&&de&&ee.removeEventListener("change",de),ae==null||ae(),te==null||te(),ee=null,de=null,ae=null,te=null,ea();let a="dark";try{const r=localStorage.getItem(pt);(r==="dark"||r==="light"||r==="auto")&&(a=r)}catch{}return $e.set(a),ee=window.matchMedia("(prefers-color-scheme: dark)"),Pe.set(ee.matches),de=r=>Pe.set(r.matches),ee.addEventListener("change",de),at(ct(tt)),ae=tt.subscribe(at),te=$e.subscribe(()=>{}),()=>{ee&&de&&ee.removeEventListener("change",de),ee=null,de=null,ae==null||ae(),te==null||te(),ae=null,te=null}}var aa=m('');function sa(a){const r=()=>H($e,"$theme",i),[i,c]=Te(),f={dark:"Dark",light:"Light",auto:"Auto (system)"},M={dark:"light",light:"auto",auto:"dark"};let y=j(r),D=j(()=>M[e(y)]),x=j(()=>`Toggle theme: ${f[e(y)]} (click for ${f[e(D)]})`);var h=aa(),v=s(h),l=s(v);let b;var F=o(l,2);let T;var K=o(F,2);let Q;t(v),t(h),N(()=>{be(h,"aria-label",e(x)),be(h,"title",e(x)),be(h,"data-mode",e(y)),b=G(l,0,"icon svelte-1cmi4dh",null,b,{active:e(y)==="dark"}),T=G(F,0,"icon svelte-1cmi4dh",null,T,{active:e(y)==="light"}),Q=G(K,0,"icon svelte-1cmi4dh",null,Q,{active:e(y)==="auto"})}),re("click",h,function(...V){qe==null||qe.apply(this,V)}),u(a,h),c()}Ye(["click"]);var ra=m(' '),na=m('
      '),ia=m(''),oa=m(' '),la=m('
      ',1),da=m(''),ca=m('
      No matches
      '),va=m('
      ◎ esc
      '),pa=m(" ",1);function La(a,r){We(r,!0);const i=()=>H(Ct,"$page",x),c=()=>H(_t,"$isConnected",x),f=()=>H(it,"$memoryCount",x),M=()=>H(ot,"$avgRetention",x),y=()=>H(kt,"$uptimeSeconds",x),D=()=>H(nt,"$suppressedCount",x),[x,h]=Te();let v=ye(!1),l=ye(""),b=ye(void 0),F=j(()=>i().url.pathname.startsWith(U)?i().url.pathname.slice(U.length)||"/":i().url.pathname),T=j(()=>e(F)==="/waitlist"||e(F).startsWith("/waitlist/"));st(()=>{e(T)||Je.connect();const w=ta();function k(p){if(e(T))return;if((p.metaKey||p.ctrlKey)&&p.key==="k"){p.preventDefault(),A(v,!e(v)),A(l,""),e(v)&&requestAnimationFrame(()=>{var I;return(I=e(b))==null?void 0:I.focus()});return}if(p.key==="Escape"&&e(v)){A(v,!1);return}if(p.target instanceof HTMLInputElement||p.target instanceof HTMLTextAreaElement)return;if(p.key==="/"){p.preventDefault();const I=document.querySelector('input[type="text"]');I==null||I.focus();return}const L={g:"/graph",m:"/memories",t:"/timeline",f:"/feed",e:"/explore",i:"/intentions",s:"/stats",r:"/reasoning",a:"/activation",d:"/dreams",c:"/schedule",p:"/importance",u:"/duplicates",x:"/contradictions",n:"/patterns"}[p.key.toLowerCase()];L&&!p.metaKey&&!p.ctrlKey&&!p.altKey&&(p.preventDefault(),Ze(`${U}${L}`))}return window.addEventListener("keydown",k),()=>{Je.disconnect(),window.removeEventListener("keydown",k),w()}});const K=[{href:"/graph",label:"Graph",icon:"◎",shortcut:"G"},{href:"/reasoning",label:"Reasoning",icon:"✦",shortcut:"R"},{href:"/memories",label:"Memories",icon:"◈",shortcut:"M"},{href:"/timeline",label:"Timeline",icon:"◷",shortcut:"T"},{href:"/feed",label:"Feed",icon:"◉",shortcut:"F"},{href:"/explore",label:"Explore",icon:"◬",shortcut:"E"},{href:"/activation",label:"Activation",icon:"◈",shortcut:"A"},{href:"/dreams",label:"Dreams",icon:"✧",shortcut:"D"},{href:"/schedule",label:"Schedule",icon:"◷",shortcut:"C"},{href:"/importance",label:"Importance",icon:"◎",shortcut:"P"},{href:"/duplicates",label:"Duplicates",icon:"◉",shortcut:"U"},{href:"/contradictions",label:"Contradictions",icon:"⚠",shortcut:"X"},{href:"/patterns",label:"Patterns",icon:"▦",shortcut:"N"},{href:"/intentions",label:"Intentions",icon:"◇",shortcut:"I"},{href:"/stats",label:"Stats",icon:"◫",shortcut:"S"},{href:"/settings",label:"Settings",icon:"⚙",shortcut:","}],Q=K.slice(0,5);function V(w,k){const p=k.startsWith(U)?k.slice(U.length)||"/":k;return w==="/graph"?p==="/"||p==="/graph":p.startsWith(w)}let X=j(()=>e(l)?K.filter(w=>w.label.toLowerCase().includes(e(l).toLowerCase())):K);function Z(w){A(v,!1),A(l,""),Ze(`${U}${w}`)}var ne=pa(),J=ce(ne);{var Ee=w=>{var k=rt(),p=ce(k);Xe(p,()=>r.children),u(w,k)},Re=w=>{var k=la(),p=o(ce(k),6),z=s(p),L=s(z),I=o(L,2);De(I,21,()=>K,Ne,(C,E)=>{const fe=j(()=>V(e(E).href,i().url.pathname));var R=ra(),he=s(R),Ge=s(he,!0);t(he);var _e=o(he,2),He=s(_e,!0);t(_e);var Qe=o(_e,2),ut=s(Qe,!0);t(Qe),t(R),N(()=>{be(R,"href",`${U??""}${e(E).href??""}`),G(R,1,`flex items-center gap-3 px-3 py-2.5 rounded-lg transition-all duration-200 text-sm - ${e(fe)?"bg-synapse/15 text-synapse-glow border border-synapse/30 shadow-[0_0_12px_rgba(99,102,241,0.15)] nav-active-border":"text-dim hover:text-text hover:bg-white/[0.03] border border-transparent"}`),_(Ge,e(E).icon),_(He,e(E).label),_(ut,e(E).shortcut)}),u(C,R)}),t(I);var ie=o(I,2),Ce=s(ie);t(ie);var xe=o(ie,2),g=s(xe),q=s(g),P=o(q,2),ve=s(P,!0);t(P);var oe=o(P,2),pe=s(oe);sa(pe),t(oe),t(g);var ue=o(g,2),le=s(ue),me=s(le);t(le);var ke=o(le,2),Se=s(ke);t(ke);var je=o(ke,2);{var Ke=C=>{var E=na(),fe=s(E);t(E),N(R=>_(fe,`up ${R??""}`),[()=>yt(y())]),u(C,E)};B(je,C=>{y()>0&&C(Ke)})}t(ue);var Ve=o(ue,2);{var n=C=>{var E=ia(),fe=s(E);Dt(fe),t(E),u(C,E)};B(Ve,C=>{D()>0&&C(n)})}t(xe),t(z);var d=o(z,2),$=s(d);Zt($,{});var S=o($,2),W=s(S);Xe(W,()=>r.children),t(S),t(d);var O=o(d,2),Y=s(O),Ae=s(Y);De(Ae,17,()=>Q,Ne,(C,E)=>{const fe=j(()=>V(e(E).href,i().url.pathname));var R=oa(),he=s(R),Ge=s(he,!0);t(he);var _e=o(he,2),He=s(_e,!0);t(_e),t(R),N(()=>{be(R,"href",`${U??""}${e(E).href??""}`),G(R,1,`flex flex-col items-center gap-0.5 px-3 py-2 rounded-lg transition-all min-w-[3.5rem] - ${e(fe)?"text-synapse-glow":"text-muted"}`),_(Ge,e(E).icon),_(He,e(E).label)}),u(C,R)});var Ie=o(Ae,2);t(Y),t(O),t(p);var Be=o(p,2);Ft(Be,{}),N(C=>{be(L,"href",`${U??""}/graph`),G(q,1,`w-2 h-2 rounded-full ${c()?"bg-recall animate-pulse-glow":"bg-decay"}`),_(ve,c()?"Connected":"Offline"),_(me,`${f()??""} memories`),_(Se,`${C??""}% retention`)},[()=>(M()*100).toFixed(0)]),re("click",Ce,()=>{A(v,!0),A(l,""),requestAnimationFrame(()=>{var C;return(C=e(b))==null?void 0:C.focus()})}),re("click",Ie,()=>{A(v,!0),A(l,""),requestAnimationFrame(()=>{var C;return(C=e(b))==null?void 0:C.focus()})}),u(w,k)};B(J,w=>{e(T)?w(Ee):w(Re,!1)})}var Fe=o(J,2);{var Me=w=>{var k=va(),p=s(k),z=s(p),L=o(s(z),2);ft(L),gt(L,g=>A(b,g),()=>e(b)),se(2),t(z);var I=o(z,2),ie=s(I);De(ie,17,()=>e(X),Ne,(g,q)=>{var P=da(),ve=s(P),oe=s(ve,!0);t(ve);var pe=o(ve,2),ue=s(pe,!0);t(pe);var le=o(pe,2),me=s(le,!0);t(le),t(P),N(()=>{_(oe,e(q).icon),_(ue,e(q).label),_(me,e(q).shortcut)}),re("click",P,()=>Z(e(q).href)),u(g,P)});var Ce=o(ie,2);{var xe=g=>{var q=ca();u(g,q)};B(Ce,g=>{e(X).length===0&&g(xe)})}t(I),t(p),t(k),re("keydown",k,g=>{g.key==="Escape"&&A(v,!1)}),re("click",k,g=>{g.target===g.currentTarget&&A(v,!1)}),re("keydown",L,g=>{g.key==="Enter"&&e(X).length>0&&Z(e(X)[0].href)}),ht(L,()=>e(l),g=>A(l,g)),u(w,k)};B(Fe,w=>{e(v)&&!e(T)&&w(Me)})}u(a,ne),Oe(),h()}Ye(["click","keydown"]);export{La as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js.br b/apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js.br deleted file mode 100644 index 33f9ab4d3d40b20b79eddffbdda89c7540fc6ac2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8174 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 UMmmYB!ESFGffZNYFHv-i2X$Wxk^lez diff --git a/apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js.gz b/apps/dashboard/build/_app/immutable/nodes/0._nbDJIPC.js.gz deleted file mode 100644 index 6f80e95ad1f03cf92f410c48971a78a4c5692037..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9316 zcmV-qB%9kGiwFP!000026V-j&a@)$5*z@*RKsY+uz&=fiq(s@K45?(@EK9OwOO`K+ z#s+~V2@?ch03=1rteU5pOeHl{sa#HynyTb!@{p;@_>Fnm5_rJ|~s4 zZ4*HETC3NsSKoVky(o-Ry(I{l!VtUms1ckg>oPRbt>ebb}d+fcI;ElJ0%IP58) zhllmgy@%ac1#Kay!x_hC$Xvo?F+Nh3;^P^M@bQ|nfHFC2ZT0!d z3}}-J#kXcGw{t%VHx6%(XHX8OA??fN&bv~2UxjQUWM_tG^3M4*diHo{2DF{dvYebg z-R}n~D5>L#u>QrYkQ-0>$L-P0tdObjpLer{y%_Sdpm{UH&#M_oH}RjJ?6zl!2Px~} z)05T;Q{hE7DI4PRDHm?pO@#xzPlY*0GZLTfysf@y9lV?Ivf&Kq<5%JN=V$ILH~y?1 zZ%VDw+2;u_p-R@C)y7BnWc{pHn^F0z8PL6FA5ZIcX~Jo#GA&E7U8!?tmUn)7@FsX7 zs)!Q?NvfTumSI|3x8lpTn(1cD(|#P>Ms}MwZj*j9abmB@8+I8}%6Y<=1@^#e+o>0{ zC*g{86}lg}cFJAImv7@S+fA(k)3D83Q8sX8m{Y|;?s&X8uw!i}wR*5la_8E5_W7i9G0#s?+ z2d2KIiWqYrG&6U0^5GnP;*q zk2%-Y1vgA`vX&Kt53*Cs;YQ2cyv4MUwFfl?-)^iO%0CeSinF!nn;-tQp$!ZETp^+qym$ua;$1xAh)+%}8&E7jPea{J}I? z-`Ha}=6Lh5amtVffZwXDtn3*hb8L?LhRs?ga}0Bg%w353(d?%wC?Oq1;Em!#&-9sw zc9NFRd$a@?L!-x|8jmJ@PC(fXI@A=LX2+gg>Ugfp0|1QsT+aqBv}$pM8t+79y8g9#oZS#V7?o zS{2p>-)H+Xu~887?GZ$Xd2IOLnU)@fK6rynveU5VIZ*3tKgsQ?R;&Z4SS&VgUvnd7 zOI1_0C7!HfZ4Pye%1w0UK-F?sOH?hWPq%w9w|l!`FY-Ay2l}u7^v^om1p>eVv%aX;XB1^eXVA=r0{-v*U6#1V^R$1TrJd&$A4&g9mi#J6 zCNiMRm$p;gwG+p7`T3AXDf0Qh3(`67|4|Pm%n~mpnn!&6O3%2WAIQEBAQI?)w;u6rw&7 zHOIqLhO&;ekFR^&=&(BTAX05%xr_>v0j+6WAe93OXiW-e7ZA`6Om+;93zNNo$1z)~ zV1zpsbT0w;7$M(4-lfdD#OQY+0Nw$>1p)*dAl^xccL)K56K>S-wTYqfDewVpe3R+I zDeWfrb@pNTmK(lVrV2~3vZ2W&j46~-)^>f*=|Z!rNd=TYm<)8%WFJZ;;r&kNhjETd zUxd4%aMfU}$*bIh)=28;{=1CiIfHd)LK z-9a98)?}E!NBO460mEW%0P{czH^x&YGfyD17xoh_nsbQ@c8+XF+(Q;cIbceaYZcY! z_JAv>;Ntz>B(4N+g-$>D?n0V=KmIEDJ~&zv+9^hDBQ{p>c#hGa1ufQFZd_&R$(3=f z1e+mOTXDM#F~Z*TTEO`R=)uH7kOBU!CpO{q;@ab-j2(5 zioc;lJu~;cogz8UvJhtiAChGWkgEs%UK0$FK|G_+vX>lq0mM$jGq=61DzDbIy@vNo zm9I6XX#kf=8bjkhk4wkegU%P|Jx-9;=7LfjbK4=pV}bUWTh$61q}Cc=XXmN)ng23K z3*{ZjNS$k5nE zt`1TYT9m83>pxgkDP>FI*f&O%mCI!(*N+2N^Cuu z(Zqv|bzWD5b_$^#5_$=Qo@}iY$wm3bkW8{2n_HHbSw=B#QT{XPjH2J#U%o5}H=g4L znTIpa%AC9G1&P=0q{;g>4|t42r@|Yz=Vdo$P!I3K%yWgyO0K|P$&@QA^IW|#Dc(z| zUQiP#7xU1~kXoVOJ)vOKfd`$}+_6Z<=P7s>Xc(F|&)PHDk~0HRm;rzs1OhUS*@V0< zMFdYObg85tr5~6|9(~{DeujC4jw+fJm;!L181Zv#SW z+#!SpyeqJ+)!Mo_b}6fn=$PyT%vbq(CYb}O@f16?ii*(6E5dXKYHn3%$*SOtGegjb zu3to@GWMFu}<*waTBN_`|!32lLL*`1No9!=ItpCq=Q7qxSFDsR#X$0G%mO z3;6UK-A8vR+Q#hhjWh=Iah&u505!_w7SbaS20^&~x<=}AU`9VLAA z{w!bKNmBH!J?1bE1x{qfFAxQTC6{*@+?+(49+uD%!`k(*@p3Lo#YnO-gM)9L^Bl zd%3@Jdi3lN`hAmAedxq57I+L0!-x!Z!5(&`kzjYWvCLwAI(E*+mFgS~j%_8iL-*0D7Kn z&<~d_fd*uF&`vvl(b_iE2Hxenf5CPn)5KTszM;|k4LzelyHNV#xzGPM@i$*A8G30) z@dfZc2ncJH-viyHud`Rw_og2@-5+Q7`vQm~{WI&+Xa=+#NyJ6Eh%V+|gCwURj(0?B zuQrU17=VFne+^RX;|!^mb|Cb&J5fK?aON1kx#nX(s;>25^pb+p88nxgXc1(uRg&r8 zepe+z(?UC&SH9^*$xdlq1}6@|4p$|wYS=aUW=&-JSehkXsxIhAX}N9GN&9ybllGPA zN&65N#vmxX%qpMGPE8oYi`*N`B{dyz82e#XOJ;ePC7fHXra|V_DI3Wt|2^v?t%T9g zl$t@q@Nns?V*XOCR7{iINQf+X%PQB+O`J*SSR-!GwA`i*{YOX3r5PCJZ5of{2sW_n zq3xyGE1ZLr{O@__IL$u38#KiN_4x5uj z3KU~pIYs4K0nWhZMQ(3jU6TyURz(?GpX1ot%|_m@t<}FV{+0U&bG6KGxMQ4`V=RZb zU3xt|bN1Yl6EQSNcod|@>#OQDs{$+2Gc?aZqUVp+Dl03-@*k}8GR=*lZpSFlGO|B* z?9}N90a3%_F>>oK)OZs#j)VDNv(UR+=)DMghECOj>*nT;;WM|KVza-!Z5V;&DsZNl zUfLdno~u9SH7GkJMFM>&a!b~<5>!Y zjK{coB6vDV4djNfaWO@t9;>OFNh;U}*JhyX%}k7hr$^Y68Q8u6*f9=RAwTJg;q(&- zI|D0;joAiY&pcKr$>(;Q!v;{*ClZK#xyT&@b8%KR>5L*j-&jVSFi0Co|mTdW$r6W}KR z{*JAi>J?Pf*5BzVeXEp|7 zo}ncNg(cgO8%-Hu`;Jg!J5cE75nj^%?PxxFE2@ zX)X6L7I&1@wIe?5`j2rH^TNy*1gH|cWq^$mzGiPpLIogq=eN+*fQZkGx1tKYHN_g} z$J8JMB|zd@Xr@qKmH73fLL)9Unxmu9CTSI_?sL?&U+6lNk)($z2stXS%V}M^N6Ns3 z@Gb>_;~3Py8I>+MTDG1eN6(CNYs&|fvkx7PQsesYIV}qRelwe45o^Y-DOy;n z%jN2WM!Eh6N~N`^U&{3{E+Sv$-5^@XsxSovdqPq_%VMpx%kj4-r8!3tdOSDzM^%Au z=f$3LMU6!(1|1#aBS%dk>M>G1M;!^Omnzj4lV&;2=)J(+l5xp}x-atp@&;<{CDvM7 zOc#`>r$bdiS$QuYE8PhH3V0SPeyg)PTa}eq&3H2lMa*Lr79^jbt0C`v7Tz?0N#^D+$IdR%9`NGefM z$;TS1vt@3%siC`e+|^BXMqd#1SejbPsd2T;A?=zOS1=U12B)=ganbIlp}rk&3#^7N zNHuI_@bolQcBc{&!G8Hd?*c)75Vc~#?Nzq!OC-$OWnP9(8oW|B8ivKTf1ZXh?RACD z8`KFSN|~K?f5+p3)F)6&zERhKzyz@Y$>;2B=d2f8Z3~7PQY8g7ZX3jx8#?_Scz(If z(|w=g>*LXpYw*;Ri;|mJnK`Hf(In*(+JF)I$j9!!UG`jy1NUV#`ff;Fee1)$)n6d8 zkg+sks?>wVnkswjxiA11OF_7Q1IF0Rkwz9Rr%Cyq_KQZ-Dz?nI!nJW>aqDNI_4Bm` z!aVAvJ%5YfFTySl5*XaaaVUoSz^tzYb`MJG<7BP}CXAx8gB$Zgf^fu6FD*&!QKDf_ zI4Enstlpbj-0i)eK%m_)2Kav5vK_8PHuSL|HW&$1Nk|5xauW&sR1%wyN;t@AXuoSc zXxS}iQaB;H(-fcqnE-b=j{ut2_=8qu zw!qpHxRhjy{zB^9=VX(~67HbhOnoHoG~GI{ZcZ_?HU&{s( zi#6O1wu(Nf4L#iPL)Oimj;9H_UBWfHZF^X^&>mCu^6kR?8d#*Eda${9?GXb{3)6oR}^Rc#Ripw0yYJ1J`yAV~;1_5!G-wjXuu1hrs8^-B8z zR9BP>b+ZW-7eYo_vIDo2dV!Ew5QBOg*#YofH_(~6%;d83Ys5q*?~20ajsHnR%ohYy)nt<(T`y^6rqngG5j ziPfLRy`O#p*1*UWLao4`1;v;QU@O`>K-KU^96>;UHKwiC5T^2g3~`4@vNC>~WcBZo z?6(S5mx9#*3eQ%|6>Q_{fIY0mKK^Z%yZ>F5TmMnhJpib+1*WU!vEhmBLw}W4d1)RnfmlTmBH$Pq=%hhH ztuV!mcHn)+h)2spVL!zhJ+!IfY9UVO2YK^(XGMkqg&aAM?g}wUFkEzJZ-T3mXgQ5y1Q*MmW9Mhrmu zz2O#Gwse1G=B~>n~$02FT1%}M@{2mj{F~S`t zn=;Xurj2a->nF@;P@abEc5&3I>h!#IcY0$79_T6!V>_AyHfU=Dj}IS*H|DNDr-Mrp^=tI!(eY1lt^?8wro%1tDH480&vpSL6% z*=a{}E&a4sg^o)3{==Pz+Cz+}_@`Qi)HUrs{1IJ&4Cpg1%pxjoFd4LQkH-IRf;nDH z3;e)NwFX8UiDzu->&U#wR^+eNwA!FXj|x23%MaHy{PC;hb&widJE}NdzVQtk7p@Yu8K)> zRLgZ?kaGR9Ry$oQ*Ma5}&^75C4>M0GG2iu*pC2qDe`3#`on5ALePRM`;>0X#S+^Jx z8~PpwVMgJ%p`VB;IgGyzeFuIuBN;(R>Y4f&PXY=QIdLa(C|FAris)l%5JuKVBUbhj zTybNB^X1vrfe#lV(xf6jFWmP?NIp zIGmrYpj}YXF(e&iNiQ~2KoIAe@u77?T7=+%5ku3VWU_yHujuNIZf!@}E1KAN83v(xhSohY_TB<5LuK*`ptQ^06=Z?gyhak!f%l-@xYByYY z2S&be`_>`?wI3z0b{B!!tyr{W3c7K)dyL*=7=?DQTh2kpGb>MRn(!)CuReqI@sfhT zo;Hu92aZ_XKwE)BZiv#7PV5EUQbn7bpU5}?YWCe%SghgF);eBAQD3|kR+-#}J1ji_ zu^!|rKzygy4o^hVey0r#W91gasO*;4@6-#Xj;H__VH&C-0D3yX_>{lZ097*QV zoU~~sM}>M|f8Y3|JseyUf)GR`c&QNMlc6+Qp@t!J z2}pjWeq=p>+NVxy)S1u&as;%MXb6Q$U9`L#T&)Yi_&uOX6N#mpEDYXd@z14oFuUF2 zC4oK5!JU4PMJrpZo{7pjl5M6oRbeL;IJ+4EYr?`xD-4Tz!^2MHI*hun^#zUaum9$M zeYF`r4P!pP+6WgY9D`21xDx~LZ;3!fOH#`&HA;HgRGi6oOU;Wr>uTK5e`9ZKL677+ zdRfz(%GEARaSw_!(~rr--%#0`RD{?Ih9}+RtWDm{8qAOrJ}z7v{T5j)6rbQ>=IO>W zBGCq&YpS34QO6HrOm;W$q{rlzm83V_x|5N6_DzXeT6J9@bJ80>Yk+ITt5VCR`a0hd zT?_YFySpPY;}u!oLTVbS!yo@K_W>`!efeSniFWB}kq@!51Fb%Xf%7wQkr*I{FpAKp zA|U9D95S+F+UTDJGjCB=B^F? zH+YfH!eaxFJCeCw%oQV@a}JES31#oyc^MY~T-~sayo?LS*#q44y;Q{!I=tvQ4wB(T zY#hg1Ys4ggXPD)F?3Zzh1GjsWsTwA)y|iPzGPh^5VVKE{SJ}SvFJJUky)g}iV`@Pj zw`t>mcNMq1`(A<*%$TMYQ)I5{%9d{2g!kpkQ(kt2hV$LsLkp+a3+r`_h&JUQLbm$` zK8>i{Ivu5R8&v$q267z4HhiZb!lXQ(;+T3Lztr#?^8 z9qJE2!3QyjDtC;-2<0f-DSl*eqiIg<)ITay6@t-veg*<~%z4>Q96RDVZrX%`Z;6NM zBqS)TjTc3L3hcnat16ycoSqzEG?42SDCc~r3#gAfFmjQAik5N?R_AI%s{E+f#soTu zN9WuJi-fW9Gex5-B^q7-Y;GQ9^A@?(ljlB8tlM@&Uxo2i)X`ZFUh}KlSPEb0`xt0+ z)`G7Vou1+F#&04Y8hxF4@KGF!&{+cCATZvY6~ik?nuN4>j@j^Oi``IE(OmeZF&tjA zg;>yLxqX~qijXE<4T*}=Ssx+$5%@bqQ>=sVjfYEcQ0T~V14xtmrxSgAManFv;Ym2; z@h&v&hIzetva+(2yCS_yU!-^2PwCZ|b4W}R$(xjq-*Gh;tS`!@B*-Z1T%C%drlur zc&LwAhNW0TV!kX=BsSh>R$#wWunW(S$ftQiR`S1AaZeT8!jB~GMV^r1{z=8XP;iCU zNj!0YE5rE*73V;~$^BEJ?dSd~G5_iFuwU%+=7Yf~!^*iG8Fb&Gm~jm1m`LWqd11bG7|S!Jn>-lE&^-vZV80|GP@( zjY21{z!`sYql6;@Z8&r4$nbzUx8L{@jI2hg40*f;);IK4iFK2{$Z> zJBqcy9+bo?PDv2a8~XQ51*~09@t};uNLTNTLp)Ig8pJw`-%sQ>RR~Pzry?P%*~XZ9Crx~VnI4(A4VgDQJ0i!Sj=5dR?aJJbnA^4>SSVN7wSl% z2AmOAF`v=UpSN1nTgLnzM=n~~{o7f$oN&)6Z&w^jDy|~=kX`O-oEqZZ0%*Apa1zj{ zOkMK2%b7f;JwSKK8}6@+xp%WM_wKwg_ii!fo?K}^`pcIldj=2PQJP-mNc$^<^MT-xeE4T8x+d=9euJdhPWLjDJ$(|`a` z1`tUApIn>(WK$pke2NHXc|>@RM^Cx&si;|f`JK0bJ(-}kfQn(yNR)R5!C=*)L%D5s zmQ}{xy!jK_hUTy>h5ckXHXYtX1)$-;C);GXH>T|S;!)L=l{Q9lis(n8A~QN=KXEZ} zmr&a?(>t~hgEaq+izFn3(nJy@08Z9s7WU3TeJ-|7noMUW&P#tf~tID;|2oUL@ z$7H>4;W|FJj_S1sT)HjJd@Z5(uB;64#sPVEKJ=Kyk;Bd%_YuQ*82?WjC-i^ipyMn7 S2sPfk_kRJR?S?v}X8-^q#v#W5 diff --git a/apps/dashboard/build/_app/immutable/nodes/1.Bnre2dw5.js.br b/apps/dashboard/build/_app/immutable/nodes/1.Bnre2dw5.js.br deleted file mode 100644 index bf2a3410dc66b7e61c97ab2990bbb74a92b56595..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 334 zcmV-U0kQrYi2@*ulrC=+nP$uWo9e^1G$Gt<0I)nDj+FoZ=6eI=iYAuX!)z@p>RDq< zOP^vVEByFvos-3y`uj@?lYtt;pBFbaHVwCmgJScl*MdXu;bp@w76srmcyq0oyA$&T zjQUN!`!~~}QtZH%z(fflG^k-hfgBQ8M1@x1I{gp+|KAg;Ag2zX!aw_E`}LO6n3lZE zj(m8J)4haB`6HBBgzqoc4poo?F!!giK4QJq-*}(SbvZaz`S;5DndC(qI(LFu4gIC5 z%4V8Gu#r#BMhy>(tUVJCp`Rlr` z?1IkM^vS?_vy=KksX^UxU>)0Hw_T-!68S*+`ODws@!TmRC9Ok8TBqD0Zj3UR)P}pt zNK^*hpaIWW$6RIm>9y_|m1PqO_BM?!G4UA?aRM=d3Mi1@io=_cfH@V{&k;&xRTR%BC1Nyt;z7x+Who~OfpgobjXhz~@N>7& Ym0xJ2+U-g%T@&8@0cL>hz={F@07?S5#sB~S diff --git a/apps/dashboard/build/_app/immutable/nodes/1.Bnre2dw5.js b/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js similarity index 80% rename from apps/dashboard/build/_app/immutable/nodes/1.Bnre2dw5.js rename to apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js index 5e6aaef..f8cfd8d 100644 --- a/apps/dashboard/build/_app/immutable/nodes/1.Bnre2dw5.js +++ b/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js @@ -1 +1 @@ -import"../chunks/Bzak7iHL.js";import{i as h}from"../chunks/BUoSzNdg.js";import{p as g,f as d,t as l,a as v,d as s,r as o,e as _}from"../chunks/CpWkWWOo.js";import{s as p}from"../chunks/BlVfL1ME.js";import{a as x,f as $}from"../chunks/CHOnp4oo.js";import{p as m}from"../chunks/BdslOLCg.js";import{s as k}from"../chunks/BTwePnbx.js";const b={get error(){return m.error},get status(){return m.status}};k.updated.check;const i=b;var E=$("

      ",1);function C(f,n){g(n,!1),h();var t=E(),r=d(t),c=s(r,!0);o(r);var a=_(r,2),u=s(a,!0);o(a),l(()=>{var e;p(c,i.status),p(u,(e=i.error)==null?void 0:e.message)}),x(f,t),v()}export{C as component}; +import"../chunks/Bzak7iHL.js";import{i as h}from"../chunks/BUoSzNdg.js";import{p as g,f as d,t as l,a as v,d as s,r as o,e as _}from"../chunks/CpWkWWOo.js";import{s as p}from"../chunks/BlVfL1ME.js";import{a as x,f as $}from"../chunks/CHOnp4oo.js";import{p as m}from"../chunks/DGcYlAAw.js";import{s as k}from"../chunks/D-gDZzN6.js";const b={get error(){return m.error},get status(){return m.status}};k.updated.check;const i=b;var E=$("

      ",1);function C(f,n){g(n,!1),h();var t=E(),r=d(t),c=s(r,!0);o(r);var a=_(r,2),u=s(a,!0);o(a),l(()=>{var e;p(c,i.status),p(u,(e=i.error)==null?void 0:e.message)}),x(f,t),v()}export{C as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.br b/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.br new file mode 100644 index 0000000000000000000000000000000000000000..c26b2c9dea5399e2df59d3add4419e0f4be22ecd GIT binary patch literal 339 zcmV-Z0j&NTi2@*u!nS$yk!2b#7D*CE5)I9(ue3KisDnnre{--@$I}1sIEx^7o)%Lb z2*x1@6b0&rkpE z%PDM-pm&;>SCPYEoPL78B_v{3n~D7FgVy?K!`tDfsuJrZnvF5 zIb_oTlzOG>)@DKhCM0Lsk@KByUJc6R)da>f^iT(bfO5zRm|J7-XT0s}Z@fM4?o=Y5oX7!x%**oEa9RE}&?O{XCn;)D8WgSPR^EVuziRk2jhgIba_g%BP;7*ifa lQeuACRlA4%I;)fBeMO$Vm)eA)xW-qh*FUDz$S6MCDFH20qbvXb literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.gz b/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..a10aac2f9637fbacf920009cfdde2d5d62f216e2 GIT binary patch literal 383 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 in i?Bc(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e;var kt=(i,t,e)=>zc(i,typeof t!="symbol"?t+"":t,e);import"../chunks/Bzak7iHL.js";import{o as jl,a as Zl}from"../chunks/GG5zm9kr.js";import{s as me,c as va,h as zt,g as B,p as ys,aB as kc,a as Es,d as yt,e as bt,n as Hc,r as xt,t as Ke,u as Gn,f as Kl,j as Vc}from"../chunks/CpWkWWOo.js";import{s as fe,d as $l,a as Fe}from"../chunks/BlVfL1ME.js";import{i as kn}from"../chunks/B4yTwGkE.js";import{e as _s,i as hr}from"../chunks/CGEBXrjl.js";import{a as _e,f as Se,c as Gc}from"../chunks/CHOnp4oo.js";import{s as ve,r as xa}from"../chunks/A7po6GxK.js";import{s as Us}from"../chunks/aVbAZ-t7.js";import{s as Sr}from"../chunks/Cx-f-Pzo.js";import{b as Ma}from"../chunks/sZcqyNBA.js";import{b as Jl}from"../chunks/BnXDGOmJ.js";import{s as Wc,a as Xc}from"../chunks/C6HuKgyx.js";import{b as Do}from"../chunks/BdslOLCg.js";import{b as Yc}from"../chunks/CJsMJEun.js";import{p as vs}from"../chunks/V6gjw5Ec.js";import{N as Sa}from"../chunks/DzfRjky4.js";import{i as qc}from"../chunks/BUoSzNdg.js";import{a as gi}from"../chunks/DNjM5a-l.js";import{e as jc}from"../chunks/MAY1QfFZ.js";/** +var Bc=Object.defineProperty;var zc=(i,t,e)=>t in i?Bc(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e;var kt=(i,t,e)=>zc(i,typeof t!="symbol"?t+"":t,e);import"../chunks/Bzak7iHL.js";import{o as jl,a as Zl}from"../chunks/GG5zm9kr.js";import{s as me,c as va,h as zt,g as B,p as ys,aB as kc,a as Es,d as yt,e as bt,n as Hc,r as xt,t as Ke,u as Gn,f as Kl,j as Vc}from"../chunks/CpWkWWOo.js";import{s as fe,d as $l,a as Fe}from"../chunks/BlVfL1ME.js";import{i as kn}from"../chunks/B4yTwGkE.js";import{e as _s,i as hr}from"../chunks/CGEBXrjl.js";import{a as _e,f as Se,c as Gc}from"../chunks/CHOnp4oo.js";import{s as ve,r as xa}from"../chunks/A7po6GxK.js";import{s as Us}from"../chunks/aVbAZ-t7.js";import{s as Sr}from"../chunks/Cx-f-Pzo.js";import{b as Ma}from"../chunks/sZcqyNBA.js";import{b as Jl}from"../chunks/BnXDGOmJ.js";import{s as Wc,a as Xc}from"../chunks/C6HuKgyx.js";import{b as Do}from"../chunks/DGcYlAAw.js";import{b as Yc}from"../chunks/CJsMJEun.js";import{p as vs}from"../chunks/V6gjw5Ec.js";import{N as Sa}from"../chunks/CcUbQ_Wl.js";import{i as qc}from"../chunks/BUoSzNdg.js";import{a as gi}from"../chunks/554JRhq6.js";import{e as jc}from"../chunks/MAY1QfFZ.js";/** * @license * Copyright 2010-2024 Three.js Authors * SPDX-License-Identifier: MIT diff --git a/apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.br b/apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.br new file mode 100644 index 0000000000000000000000000000000000000000..624f7190fae7667e73689b06f4c6dc178f2f6a78 GIT binary patch literal 124081 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 z zhq&kLvNQUxAY$}5I>j?zvO)QW>kg7LAVaB)pG}1O>j=S!-AtEXJCB0 zMtJaAP66MQRIrEjH|ZZZagKU|;4Gvjd{;rH;_W z6QQ4#Y^O;ueXWUX$*ckOljJd}DN_&RgF9K0tgQ+bLPQ!JKqUbAiHFubiK&`p=t= z*1;D?!f%HVo(5`t4x@~v9Tbk&uVE5!(bol{L0{avU_(VM&z6mr@>aO&6u>%nqicR-xh{ghODX?(JP z?}yV^;h2QCs70hWBmeu1F4N9ZST9u<31NjWQQZGQSUPdx868aV$;i_vo?9#n(c(Nm z`3dR#wUp*}r4;x{9s0^(d{eH1W*j=wA7_;Q#Oex}6SGtF&x6-(LRC@JlWQgwii-MT z4`#Sg=K$@ws(HX;6@P97pjKTiX>e>!Pnw*Ybaa)r`Qmx)GJB4LI02y{Yp1j}G}o(x zNL+X8aH<+Jd4BCctAs92L}&Y2O0^>k_^v*qfTkXzvA2!VIg-E6;7mx946A�NT$j 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%0D1J1=X(yN0c^(hkgVuYPFE?Y$58M*$v*ypMWgw= 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 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.gz b/apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..58803e2829e500b39ba86dec6a2e2bb405303544 GIT binary patch literal 148779 zcma&NV{k4o*Y921wr$(CZQE}5Rok}PUAtFpch}mrZSPv=e$LnTne*P6%r9C0m06j| zBphJl}4ibcR6MFh$lL=gTFl?e|B_ApIA{8 z4LwF9Rl{O^LEuAUUn=Og19iR;a4uU(9|BIKScL`y?#0=u=W)$_#{f`lw1Kk}O}yCd z+EV1&CG-jvtX-gfFDqAhETG{1=`tSpZ_PZ(9*^mi!;2Y=uVzWL>K@@wP8xW@q?>m_;S*>Xt5Zwz*D@Z#Q>J+fdR|M2PiVkh*9cPWb&$5$~j ze9N6VefKLpg*JdV6*6E2)|I&Qux4D9n9^bzEQsUN=r_g4Eqvn0Yp;TA%@=>DnS2D5}9ZN`4HP*r~~8%*awWdj@pMPYCMN&_)5R>`+kQu+A) zc*WfAbRa#-ov6&jIGMB`b4I`NY9{2Baw*_%#ayrQ;QoF!%9A?krSnA1ZbC*eQToJn zJJ{0qm12KwmvjNq6Q{XeFuHQj3wB_f5Cmk?dyUAz;mg9r^5uOC3Aws3aqH&w=d;tZ zb^}SUF`SMuVLVu_pCH~??s=z9Os)Lwk&%oGOb8;1&y?Sxv~OIj#cA!{U+pcwFyhxJAd zvf4lIiNojkKpQrnh+(pXVxm0%QGvXZiP3XQ9_2>BOZbp`>Jg0$Iz#m~9Ga-OhzrmQ zJE%|;`}BwscGp9p986R+`)rAdE#%VezB^AM|MZXz8z6$cTcRckc%DEI25$~a+@>)9 zT(bx%#M0fXP&|1(PlCs$5%dgR#M~nfd=oh@hEMBr4_>6MUm|xltWZ{C_{NALCzp{C zG6C%`enIPPuu6*aOS-avnpk0%@!|-zC_Zf|CNKtJOgm%`2x?^lY#dPr@EtiK6cYI& zbIfx^<2pOIT^+Pb29&-!rotb=j|eHQ)XI_o<_bE+*Lq)dC}PSf?=C#lkfo z!XmNwM!H{XmoET@2|h4CU#D`CIb5fbKNBY5j@ffhK)!Es@mlV3>4NcZd<7)Nb(Shq zZ8a%lZLyLx1iNp4DWwV=BIWk%Ct&$b6FRyq3G#oh}%dD=vP*2ZS`_Kc7g7UK9K(P$Yk)S=+2W2H>|K-YtJN z2on?gf*<_Osc8{y4Mc%weEDy(<`^(K2R#4T%EY%Ex4R8Tq4nG=psSw6sqp+T3k*w( zY(MLrlJg69!>qjk_Nt(=6CTfxZ+|F5hE&`jE_QBO(&<8twgszE4#Tm1!C&;e0z*hv z?#!ih(o=%JEzy^J|HXe}fRcSs6bf3ngH)lXw|dT)k13TL2cqmAZpq+HfPIw7DLB{z zaX%)86nk+?t5Uu}C{2@7pzucH@>Iy72b=`TXk!~#QiP?|p~eLxWJI)GkF#5i&&^*By9f%`ftA6yyH_*!P~O#{UJ7@1IbN{|gY`KcN!msCWC1tV#p^A81c}eMa3C zI@pv3d_*}D-(QpW`H%dsBDV+teB{5tDVY%VeP`61B!KC_9knp_)nMd*k-URnnNW5i z54uGF*ipA&_l6{W@FV}LcuFdSeD51ICk`Mwctk0Td=(h^UnFiRfceOO0cliXNdU&Z z>d612!z~IxANl`9>ckCi_Sh^vcRuG1(e3*DDYS{lHTMg|nMpH3@886s{6tg9XLKQD zlRmjKer{Pmb&_6MmL5_SkL+}Fzmr{O&+b!B4?#dj!>_A?8+*?V z=k~tXB#rPgx@-h9+3TAZBWbBWl;tnKu5Z2U3n7;Pes&g$z`uL&?3qfAHWaX$Xf?@F z%%zy|g&nYUI{2gC%2inkU07q_hs#^N5cWa*UyWkX&bGEjb1d-+s`o$ib!97oWx8QC zYZ7`*mw&6@IrWyw;>8jub>HSMwHKk#LwwH5R1wfXJ#GZx$+#Wckq*}kksj#@L9E*wW1i%68bO}sh?P;*NKW-2xP_X7@t>Kj#ZUnWUj~VS zxxA~&i3RODghGT$hw(VEdB0cn2sPB8m$7ilsBO(rrEN!&UMC7MLiJ|_ReWuhjreH2 zYYDqR<=w516PI))TeXR7Q!A4+;+#lGV}(n3)>GvhtzadR6q+J1K~8$i!8>K zy-F;*&=tLkVzU&$}OXWrn&55-1uuz*$)+iJUt{2rjo|F+&vAMD8+_CD~quJu&AF)L`gqrcSc2XH}{o!rZ zC5l}p^Pe-sOJdW4h(AUVh2u=)1yh?l;P>v>ARse1ADNC+*9yI=(lU8C-VL%~y7NJ^ z#lDrYFoOk0wZ2AWtw*)~Mu_`M{F!-jvkpXy`=np)gAgn{a0fLCsI*t{^73SC!$p^f0DUwyfh zSqX+8gTN2U`m4af0ODxKpu?=l> z=;4t|Y1X;yit+5+=L9@xm!Txq$l<1Yzp4=-hzq~bXB=qdOonh_%x-ab4rf}PZ^ueB zS6hLR*y4=3H>TA;e6lVlG1br{;h+70<;+3D*l1D^UrJ>-C;Fx=$*ih&9$5B(tymJl zSHM&q^0>*lN+;;*pB#}jvvge?3h5|k zi@LwJ71;4%3)suTLvrG24cAr|I8l<U$QForWzbGt-n+3C-zBo9Yu+nqW{`F0C-e@WQe;PtAIpXfAuE@OYmGvQoD zshFer5px(+JX2;vB_9K(OvVOAIE<{0^fRa?ydJA-Iw9%U%eCOy;k%J1Bq`ySqrK>h(iFS4?QTD39Hy*q(}k)^l|THJLQKSVzRPtA&z z56XCwQOAPuxaaJygr&ZbYC~v0PiSPkhH8k%MXos+PqG^5>2Zq9iNl(`w12`-k^oDHF@m5o#OAHN5@fCmZQa<`Y*UGqJ z{Tyg>LG|h?I+n*EMiz_QXZcRuN1gmgM0;^H;+Oq0U(4pNxe#vGk6#-yjMjB*x zJcd3=*rZfUUC4W+90h36`QH?HU)Wp{y5~g|(I6I#D8;|j$DRY%JVb(p z4ETaugB~gP(r6XFNdhsbBhvvhbcwG!CmpohFW^7iCj_Yy?g z@;py5daag5-xyLkAld4248GyOnn0e=IPT)|S@a#{RXZ{Rgfj^Ll$a0jCd+2D5|q!F zX*d$4h{BuDLwT}$X9jnD8m0dD{=1o9ereRj*|}AZQ|np^L;2-u(4^6uSN?R6>Asb7 zk(=F77r*h=&*^nW(JOuHJ)Xi48lwUnE4bUsi#g=a2b_#V@~*_}6BYdpJ2C9Pdy2u_ zvyYd_+_Pz6@7K3r3NQhB>`b#K%Z+j1)*@5$9iz(z^eCgbrU)k({&KUaWS!G1BJ*AG z7O{b_pzh%a_B}pzp^-4I;IFsuqtUa8TfP?c}?JFz-2FPruU~{vr@DFp-Yn zSHAy6n~0t@vAsm&kjaN4pPuDh)lTbak-pq5+ZluhN zlQRf}ZZ<{#y#5#`;(g;(Rz4v5pdo-K+*BWw|_TwAGyz<-6gCeIngr-J*ElG?SBGw#o7P755Lor_RDHD`k0F`F!&aa&aKJ+G2#g z4Tuir@Hi@}0C zqZ6$7@UI1J{q_I3DO=m_d)YO=Lw@;`l0(Od;z(Ho_61^}@*3y$`MrhV#t(t`cXV&H zHfJxc@ejn&D2468s`nkKXUvBbPk|z$`F+i-D$@hl8P#I}kN6JAsBsQ!*r0$!6p;?` zx)@QEO)T{Ce{6MoRxXzVB!@mXO0-z7s%t@b+D1Zq%@L&bUkD6iCT!Z-nUIb*xy;@N zDn##%kSDV*w;Cg+JJOiLa65wj_cv#igDU;XUnI5`wZv{+UJ`TSp;vAsAyCEh(IB9E~R>%MSGRE@gf`1=uj-V`#b?LHql<1|tEf5xpH)>vD zc`y*y8jT}RRYfj}xZP#eC?~S)_HmGP7*Valog5F~^Twt;Z<%-aXOCcJqoi`C#ak@N z+9^I`AIVPQOT~X|76Pr%NLyvv0S_+nBFZr5+`*ENP|PpRj?~{Vu{0DPaWN7{TMV13 zBF4RDB~lE;|)J4!<)C6Gw+ z{UIDfG2yN4vBHCVhd!EDaf^AhrNM36KSs0cFFVIsv`6&biJWi?K2U1vq ztIwzTGSPd2Q<(k-pjG1-7Tsg;ZVug^>CWsX=ni_9to4^&x;2 zE7h46iRLJ!C<^xN_kuIEvk^YKgj{cR22_zD4UvaqcV*SBs)3JHoct_C_PT4G!XWlR zC6#CVPB9$G6c5hLjZ+j$td2YibQ2HvdNLIR>jGGxn?6Ud=&!51{L7gLiS;Jx7txU% zBp}2WMD7@E%Ymf=@#rVcW^Bh0c(RsCIMrHnSP?JGfERKaUz6Gy4+TBe5-cN{9e=j* znL0Z+ozl-OjnWS_W<|fGtI)f9xhKC$Sn-_Q3955R57oR;wMz%(My+$3?m8$?p9liZ z|DhJO%e@OX!z-wyxpC&85$9J|*qG4fU=ul5lctd~!wQ42#mocacCZUx!aA-TFuboU zzCwBqX}4d1kg%T*5CGBJ0_ErV`h0zVd1`_)&f+&-xb}vHw(9DiROc!Kc4{djAULsq zd6>#wal6y=C1J%v0<0Gup4Vy97e@X49fbGVXoyJCe|JYmOy=?x!cO9jT#@zWSJNK^ zr{Kbt{vjGF`hoeY5PxSHQ5=s)%)Qpk+w~wU`}D7@Mb|mIu#BkO`8=_(BdA9H%B&w4;U((>yTEz1glwBQGLj!n_2h1 z>WChiu|oe;$jrLSgG;uQ0Xm)G1o%h~DzxJL7UhU9r4Dte9X(>?pxFuEi-YRyfH6RA z;kELZB`BG(jjMv3Mspa%nu;t0#5~olo}0Iq(FYYyk6mk&WRyc_Cc##&$*%&E1{M8? z@kHdcuv&S*|DS^DF}D%Rn`wN?6TU#gLbR=Fo(It4Z!{z~YA6txY}__kt#vbq+Sh8- z%ck(UVx@V3$z%>ke1p-ywAGWtNwcdryP-ZQB$X={KJ1`Y&eS_m z_F2O%fW$Y$-Ou5Eif@+F39rbuEFg8M5MJ7nT+SP`V)E8xQOd?EA3kT(!4~xq*G3=O z!MqDtGI+w?aMc4jN2PST0Zwju=R`W#-q?cv=Ke_wobnXOiNx>_tM--K@U!!AwtKSW z6{v8VU$bY};wi>FInv4(7PXp?ar4t+Cn-z$z&|mYJntMeVTex8j&slHn!fA6!gF7< z{nw$|L?6>FFOe_R6vD}~U}A9MpyY5XUIqfA4iGoouUdR~Ezw1OT2YcHCAx6Tckv}I z*e*Jng>_~oQ|rtSpziUFk~x;U%lp&D#(_zFftt+LVEG^Km$)J&3UCHl9s}IEO$~}7 zb=y>_F0!o8XQNNHJ{oCC??Eb| zIsE=Py?!*neA#X!>X5WsoZQ~kied;FfzoU?5}_ky(tGib|H_6x+N!}{$-M3OwT_V1 zm+#zw&9Edz0)F3W$0pvklw;g7a{Nr>MnrBV;*AUe!g32~hWI{csu*zbciHH%vL-3K z54M%ilhTva)A5{UNqoxJ;qbf+2lMkd<9DkHFfu?dkD zri`G`_h7WzRx})I5fX?O>fOAi0KG(cUZW#0+ABWcA@`-qJ~O0CPkO3~@j8T=P3_wR zBgbsg`FLrZNQVb-Dk~x)jBy1LSLm`~GU**_^o3^j-w-pqBTaReQ5kuZ*J%Zm#|iYD zF0Ltc74i*oN|{F69$g-qUR@sP`An1!OM~&$3W$>d|E6ixsL_97)GG@ggSGYcA_03B z+J(lJ^D8Px4kDZ4$;UsH!1@rAQ1cX{Q1zcG^(Ha8Fon+nT-{pRbfie^$r~`iR=f>i zzoa%-%_WqQUr&e74!9`@qq_ngQ?W2cy;*yPUti>%B`u5NQy+)pp7`3H@wQKKw!&_4 znWPgcpEISsdA6RZww|Lc!~(DI42y6&GjOlN&>^_x2#J+L(@y7G{~5`R-dPIT?%>S7 zcKHz6%Ou=)d64h~A>?)0gD0QR`5Dy^ySc$SD>7nR!=sH-F?#sVhoGC5%v0kxri9(2 zj6doGR&p2HVq$)nlfktu!tNB#cPaI6(NSWf_X*Mh;gRjdKnBB>w^1rBQU98pe5|m% z+Ry`B$rg1jO)MJgapJX>9bbxnS?2NuT$G179ia-a7evb=9*K5hUD7}xGgO^hw`1E^ zZXNaG%p$Z~VT)JHh&$L82VW>MKRVhT)*K|jK>!`?j-3>=AR2eDBHUUGY>SX@kVer9 zKbP&>>M8uGXrbkHSG&m7KMh*((jCg|#5bcY!Z!YQt11#(-Hba*LtCxlg=3hWK9aJl z6rqZ*YqH5uGI+G3eS_qRlI4Ve(CPj=8RF`ZUj}PZ;_d}B3Hs4%B~%A7?1L^n0*Hnhkdk^crwT=L5_qt za18Npjo?;;M^C2Ca77snLW;_W8RDqA#JvS`gwOadx1DImWb2R1vZ7*~e7gy{$M?V0 z&AWIt$8;ZcnpjV`9rvqze+tzEM`NT-EA#l=PTm(yWuBGFYS{%Ae;u=EEOxs!Yf;k? zU)EfatZmZVKjP1|(+S1!DdE;sPFp-aSRj-^{-=!Dm~lznFI zh84*qnOai(VaX3O_6`M0A`#a)K}kXVPqTv3{65;wl$A|inSB4_#Le-CZ&}QZvpT#s zV80HD?T~>a(;2Jrz4b-pPhM-1!HV9Wi^2|mF}0%bBbs?JEn)v%2n%&?DdC~+u17}< zPE(x&8d05$`IdmIXV~!2L^ujOA>BK5ZuPCO``azOWN?FH(3--&)q|gIdrTJst-<>k zniMV)@lXwz5n(sjP#i-r9JldWasM>fJxskmVRuXL_xj(raQ^h?`d>$$NHPrkkYzR& zr$qtZ)zAUI<+y|cD&^Yxj6Dz`%Ym#TkGQ4p~7|;sW+<2az<@yM;=)hhZkaK{I_f3!!${MYIJVvP)lrQk~y@q~|_H8%QT zVtdV|F;B*pQEY*aPaX1QF{i0rN5|%!i2fT8j5^X)X#K{>=XVuXkW2y0w|!C0m?^j~ z;6WEdz6 zFtsI-@T4rM#VF6Xx0REaPfTDk<}ov0oxN4rK-HP)|L(dlMy9{PYF;a2VH0g?u4Qw& zYefyk02)Ynv^58B3tu`A^6ST0@veL1X23s{PP&ySyQw;T zDiDoaK>#NXB(5Gg*lD41*Rh5vN$t|L3@D1|)jgBNMPKkph5N&0PcycZ>+cyfH<{R1 z%0BJY$hoFqoMpL_FNA>ONzrA(6_OH;LEj5)nZRzW$0tl7nP%WY%)XD7!HeU9=6=4X zrcQay5kR({d=n+TeT@*HvRLnq&tj>0S$93Dm3fFnc5-A>{y2U@8E4JZ;;|%Nih6{k#W78S!EM&oo$Xy zmr6eFh(B#J8;g+&6L}k^G&*KYcTH}(fRL&fK)mbB(eJM;Hb3tZnHxXlU7C}tbp3#6 z4MxymkN24V73Q2$Mq3}!JH00teCCP|z(nzp-qwlD)0iX!>R@Vy7h3fPEnips{JPV{ z+IV!{nIVbEsH>`Ui~pPQBjbpJQ$+|)zBNsPY`kysth-nK_RB=2@W4=8wr;|?Th8vF zuLc4-$o#}czT0Jg#F}Z$fGskfp76|OUk{pZ!@-x_3>(exP^KZ8yEA&fh*~;?ofn1x z-mwEU+9BPB6rItsq)LHf5iMTyDXuRNc@Oydy&XFD@ZsG8QQl+YK3*>!@*0h_ zRXbC?gtz1CaiKuOHzWPr=#)wx#apG6^jR9&kogFY$DOcKK+q3()SJ~7;?yQTn&#_H zeWcCSP_7I0_2QoD>1uv1NTCUpKp<0csn4(Ui|K?ES?Ou3tPlPo>JG6-{45N%hpTU5 zhgyX(a6eKOoQ!IEVRH+y1EG8@vS6oKU*m(Ro>f2CpF;>7y92H_lD;c0la5L%^;@uI z9)(LUqBhwZ%8*EorvJq#;PL~3-CuKG>*cPA5;#%TqOVjlRc9e>B?)dbewx9;C9X2$BMX>eA zMX+*&L@=4Y5=(Hdz}8cGX-I?Z{*v6PQjR>e;PRk(#0{dBn(sph*uWxTaX>;t5k_50 zFzqU}eB3XcZWlA0mBc(Co9X9QgOxfPj3-smbwmoO5Xh(f8UzV56_Ba9PTctVcW-^a zDu1^M_bMFtnKo?9JZSu3`z{>#{+jxFEA>+`M|?X_*nPmf_;deg`0Bp;&Uu!pKR&6{ zXL<3fV~K@gcLUU(h}y?SVVvKo1BlQcu|T(FT9SZ2ZO}@baFNUBY_DTyAKp1H{i64d z*;CAma8TEsb9Sx&rUS3tr|E^6)3W1CUez&J+R=fyg4G?(ypMf7`bi|1X*_^^|M3JC zY3Olr|Leu-GpDadw^TC*aj3@0g-(_0FH8wUKCfT-OSrH-pfk-a13X^VT+d zloR=r4rudBNL7&ILA3eF3^!|4sxL`dC3gbQwnq&9Ei;_xFn{kZ2TXB^ql3;UY+`)p zvh^i?uWG_gnB)0VKe?BJ>M9c)Yau+6Yer+c{QSNT?7E8TqQexdu*y7Jyi-&q3- zhd1e{h|*hiumYUDk-LOo?ZPU&7C3@e)U-Pa3urUYEQ2EZ2Yjlo-Z&diO8Feh3mEO$ z3+=0uPuIQy+q@PQjz5)CXm|x|*5%>@Bxr6urI+a{V$=%BC5-m$sKGgR}uXgg{=>08{|q^P%8@C~b(C2tzzAM!j+);S>D zpL~?5y-RSp_HFUJ_oY~g@s#+?-9Okx$ZsTf)(!jioj&nn?XPVFd_b?fm!j=EXK`VD9|7_68C*{$@T?KGOL z{9cP21*dfDV2ALnq`h=#83L@YmCj}n@y<&kdZNkxW0B@}lPN}EXR-!R=0w1|{5FnX z`!@hy0pK!&bv+YhO0--aJ%#L4K5nm#fXl(O)K$dbpkHjpqd(IW{h6Bjmkgquiv;WP zS*jT6LopPb#P<5S6gkg%n7*|7XH$Wsp$}twZ}YIalRU@?aYFEqESfpFN7T!kMNp&9lC#?K4Jg$R z^$koy&6qp3<~1!sjf3}uj3YB{(-$Rq>!8JmS619#tW?xZb2hbH1*!HcHr(?~1*sFE z)a1?u3yUj`bt6mfwGcM8m!i07MH+HPeb@%;WNsro*Am zWn)z%`_e_ss|W!x-?L(hic5X&%D6Z}I&$;a$vKDt$sHnZ_IudfXAF$ zI!TophkZh5Ua|M=?k?FW`GQOo_EGrj=vw$!*Y#;a>(|kKYoS2n^Hf6B*O0rd zurJy*wQ}KCGrM)*Y0~;GuTJ^mjzLVd?*CLftwbLl#c8=*8=WYxq6>QqrQ>~|ErXKN z#kCX9w1n`#l`=kx_UkB_>AA7d&joovhm_J`U4B+!bnIIvFQ8Z|BKU1=ZfNwg$6$K) zudPAXd20f}+sWTi<-DJzLg?lfI#%Hz>_>2)CY~VdLtJcn?bjGOe`-gY{EZ@K1I~J(h|o9Prxc#GxR(NPLmaCBPRxO+)9kTq6rFGi6wGh zrJSijW|1bc&^HU-40g^67!F>SL%b8!6b_h+R_xlV8$)awhzkOEBW@9DgI{oR&@XGJ z%Eg4P#8Yt$=tFa_cCyw7RR}W9V|&Mp{q3Yvb*Cv&av>+XP%q^ z47>y;s!`saLLu_^;Zw06cIm!v@$s&2a_RQ(eQ>>>58}~xYh;73$J6R>^@@t`Z`>+k z0gNYaC9$sPnM1xzuJ_559*=Cl_3Xf8 z^pF8!q?Xk1<^bYT-^-lNX680c3LV$v(Aw1;&iG|&(Ma6>;AXS4W@{_Y)ceml`@-ad z*uqRNuAzMOM1vnUUxU1kd~(ecbu4bYe`N;a976RS_5AHVnk~84_&3^yk~!<6EBjkq zxf5!B+$?@alfvX_P>pTzmrXb8^iGN*y7uz#EG{5Hj{ULnN-%MPGhHH9sScSI7TNB` z4qC52sLLvQ4$Jc_YqE2`VW zCRkM#_6bh4o_X=)wbfdwhR|O9d*hC9sl9G1p~vi&WAQ{;YU60)Y%)z!fJ!?qb;p!};MVeUU`Z3#K+kd;?gfSbJRryDzOAXDR%I{%+s+^BBUybc_F zEj-SYRp84&Js{^^*%cxUaLhd6`>>yD8Q?7(3pIR5g&No)^(WXftddyX@hgzPmbrZx zMn_3%h-SIit%`yh??t>7hw;!&M2Wh(-A=N$;h#<4z&6`O2d43Ovey8pKMK)&&Jvcg zn-Noy6H&wZFBwc`2b}96wrVLWU6fURi&^E;haP)w3&Rx*xoDHB6k=u{+mkf|d3WC- zrZqu?@dp!gt2@8q+QgpTm9reQx@Ah>zac<67(phpTQ9qC%osQCChz$lIr+E)3)_H& z-ZR|mGX|6drE7mZQFYMJwUy9W&yyav#wwaPHZ-2qZ1k}fwv{nuIrf1T~Gn6D)&(o2=lzHnKaqZBs|L68)oR z0rmLW4uGGcM;4hYSK4I7$&`$)U0B;%+%d&Ju?aP%&a1^I-LYMc6Am8)@ATCe~FOF~~*O1Hi1GG*+{eI0{a4sLe4* zF7uL;@m8Y1(2@mEfkHPmh`2?)4Ez}x?_h&prZloaY_H@J2m{~eo>5FyleBHpo*($z zIZ#CdaAfM5X8Ko)<04ITErBUuEYg<<6qzS#I4;sw4$D;?R%6(o(Gf$3A97~gPO0! zke_aG%c z^W<$5IH#R?RHSOj@B?U-MZ(h@hxwyjcw{ox5J$sh#%$xpMb8{2Z!nq2NUZNYp%DqV z1EY^dF0WZEKK@OWGvb*cS2SusaR-LS|EopfwFcKdYdbZR+`Gth=^?2ZqbCK^XNIlT z@_t3PhZ9yFENLd|IHPEh!@vaNm9Fqy6YF+T#3kLdZ_=_FI=$RRLAC!lCs2&E#n%s-g|%QqwK`3A@19A6YMQ`Gpl2phpKCDae$ zUFdId13<(!*&N*G09+~-z!j7!MAGugpErveXS74^ylY+;a*883KJLu@j6wpGt5^U4m! z(GVZb5|9jM`1RKfv2-&gr;HIP-iFKJIVVAdHX&|ML1kJ`iA8gei!w(ib0fuu|3o3s z%GfF+P%8H-*sU~mM$O5Frd8u{%{Rf$AbIz>DV%y5|b1CDrMmaAA zHVB=R-;7wA+zPi5{&isU(W7g zlSCP#NWC|O_&NzzhRh~ zEJ5{JO7oPV61!3r4@Toub4c5LrZ zaXd;AjrIk(h=*)iHCaV?nE003e)LjtLf$O9w`k6ItSv9sR746Ktqsi!tRg&HFKxwtxmCQh=2BQ!}b zH@YL}Rj#8t#YKa6n$-^?`Cogj2=5f3^%nES53bR^F_CLAy|q%mK%Z3o;L z_7$5~5JcM!G<3D=O0xVmA9xE#8ul7`6eWD6l@`lT5( z&;2C2-!7^D#=x2h_hg>%1k zogTOl66XNo;xQK&TeWP4>?kvsjc|wlb;TLQy|B*K2Xalb$Mk|_jX&jGkzEpnX2j*K zn&J|hN~j0sOFpvbtr%8;ub42cd$wP=)c_Q*EM&{qvS*067<3k5o-T@e=J(`u2d3kMHCX#?{P5G2B_7$JL~}&eSp4)!A7rWBK4&7>FC2 zEDHp%P7g&NqdH&7iP&ngh+6E2Yd^7eS5%Uv5=2ov5i37}zyxSalz~BwFsu*Z3Ofi@ zkBf8WOhExytDv#sIOSdR#TkT494FDw^_TD_=pY|F`2w;KCa^QH52QQDpWuu&KL)Wl zq4ZC_{YhVm56wQuVRc2?vhSG`{WKzY5lz>ieakwSGM^-%f^O;}my;YnX6mepRH%{7 zZDE^V#Ev14vvXoEYZb#iv7Je4J5yLeE6Eku;(i-}84`oMiJwQi51kx7peFAzb(5Fz{^ddAdx|Lrup%cHYffpAwitGj8U^68QQ%@j zEQh;lHW@%~3_6SqW;6QY=kzd|jwv4V&)*Q4-`+c&8en$iGmvvNtF3ZP{8EZON{RFy z&C+{A!>|X9!gj_A(w_grNk$n@)ZB!|huM^)W4tHjhdd5vwxBAq7HY+t6;)OSE;)xX z#%6*DY7ei`L60sE^DC198ojB-gJ;^aKQNJ)YPVmT?tb|0!&}(*y01QHVK`wi)T+7z z84XqmhsV_*))Oz0E_uWU5~rc|0%s%pkEU2q3JvoAM39la`}*}SiE&DUjDpf)wT+#R ztcYBM4=so?4@M<#BD6d`m653nNY`M;9mR(b(TFCb^n1$Eb*O> zfdR}dnc~7LZy>swlEdH_tKBG41~|%`W1B&v*FZ2wt?DH*p#JOC!As?lsEbm@N=dM~ zPs<<)(V7agrFM0_0RF1qwN1>XeQ`Y|Ze)=>Tc7$8Qpx|5<}XSDF?+3Fn8MHJv`z{l z`0y6u>ig()n4&DY=~gmow*G4ITXic@(uD5mR`K1su(#Oj+J9cv4&L(Wq@@CHIuD1eU2Y^`91hb*Q`vj2 zu!RJB>U~0}_48Q+_qQ9or68lxYpsp zXeG%0>}-w~N;*@Yo$+t)Y5*Z3ou!^y9lF6DXYlql=$;>h`H-qxBcFBZaLah5Tr<(# zTa}oV+6B4mC1~|eWuJ-2-fK&nh0;-_K4O|{DQeh@nl%JuTu~6}5o?Hm?0gAVwN&13 zTh3}`UPUKOm18!#rbCl3_81;P`6$8Te{m-N2(}fFcg+2{{Vrk(y6APoAQRZQBzaSk zI76zt=(9cWMGJ+#P5zT3mw6UZ{414LAi@SyUE8+zPvn|qg+wp~Pb;2VbIm%nAZX!` z)elT6F|!m}p7Bkca5W>Zz|4~sn>@VJPiD7+3-gGif7}vce`Z5iO2rV41AOgIIjec9 z67tR%qYt=vp`X;_NNk09 z1JLgN;k)i`XCxmJ(9pihePk#o-^V79Nx}q2LT_g*E2$ik&_#Zr#!=}-#1HvwJS6;P z3H5$l5YAJ<|2g`S%i66)@7gmpeI!2KNFaqEcPK%DAS|-7)4$@)g91R#q=S@DV;Gm~ z3P4`zgO)J%q!AL7qigNVMS4I+b5QNC0Dwq;}S zPTl+dww2y*-o}97{UOpm!+Sy*AAKH+kphGy8pmk$v8ySN=%o{xH$y5P4bz)Qr!2d1 zrI}~&G7;GbsK^wAE(}UsJls?Z?EbY5wQnqu$z3p+Y>K(PDI<9~)f8+P%S4JYg`|o* zNApWL)r3=+)+W!gE)3o<%KvVX7ptkEZ`i-31x z^9+6HS4@(S-^XbQ)mj5glkW+GH&>BGJk=&sCZgf(d}R6ha#Tu!SQ%~rpcPR zmzPLbtP0)GkyvM!I4~awuxM^C z;ZfEZyAMvr&7X;?1!@+snR?OjS#S^X%tg2ip?Y#^vpos0V>sROvAqHj^Pojt1~v_6 zO0grMuHX&(JXBC>||_zL?AnHR>^~fO}Q({D_ENyHW}DpCQ;pk@am^^u>L&a zyk<2@30nh37;L1FIkG3yEcat5vLL0#K3fCN{6k zbdW~2Dn%V!aILYRbdy0$%GenWx${xtP3TW6X51Jfw*P#VV&EHB@koe1BQRf}jwn%9 zuqecdt!Ke7G$rd6>tpJsU2pR)1*<+#M$DDO478(p)GUwnfz}-@#EY^0A3IdDJke+F z|JsWGu@$JQuU?88H6`nOAN}#M@Nx2EzQS^1m{i9)eYetPV%N=_;^vOa?S!VWV*B*~ zsJSs6rcOHw#Kry${|9+MhQC~yB<`399qmqugY6T{l+-!?P~^8Qr%ykZ6J@Bg32c_z z%{hJk*__Hsa$`Vm!R1c)WXs-h)aF8Ov!5XD_vXA%%~fi zuP7FUC4>N!OPjb1Wm2{pA!Y+^vRv>LE4)3&<*$H5{1p)PCJ5f}8rNcAq+4_G!MYl5 z7s6*dmTa>SZW$Vbsetn#b2i~L!Ko%N5(0>G#3obLY*GnEflx&&2Zz{C;8$riHZHH& z^~$I=v8?J-J`}GkYisVo4s=>S;vP0Z!p85FWgQ}{_;4MQFIe&wAE8&~wNvit^A!7t zrFMimm<{VI^ZF_G*iD&!WC@7P)7)UXkwl-I8PmJ4`GB8?;B(p)HWp@MUM!+Eoh|pR zsCYQUKqC$drp=E>S&aR2Rw!N=4V8FgSsTziz}c7Bsk6P{mtyRVmlyGYHeOuB$J8@z ztB|GbiHO-I2$$`8P%R50%R;g)$|E|&EQ1JW%(dIbn}e`5nOC_q@3H_p~u za*w>tLR@XRguV}N3~_Nq#EG(Y_?E`W0@rW9QFBStd8ev5$h9WC6FJ_iP`sC7#@%6^ z-G^MEwbT+J3#Ss+5{rj1(GZ*S@OfK6zI5spw-!SL7i(+k)LSsZin;edJ-7yuk7A7M zW)XAI3b*O=H~+-4a3fz#Yq)b9escqVyyM~3Y9Ki&-AUF-O6Pdxex!7KfGyV}!5N#b z46u!j;lpP$gEO0da25nU16+R%#1v<6CgSu&)Fv*=27Impz9LdzgaW3zjgIcQ*u~E( z=S`f>qG{|dX1@0WwPUNgu~p63f_n>IM@+x5`l-%X-Au_ytDC9As)lJksFrcQI;2*t z+cNA9bzqd{2P>gfHLIa1s-eCx>Y-H?HPI9`QD2r;#Yj{|y}T}(qAKkCMu|Ht>&kOs zct$LFVD}D^S`9au(zE0ox7@%dJJznw))nqhlW0Of6C#>WUD6>Neu$&_utv{~3p$Dy zsTrHs3WIsPUX4wbip$kPK2gE0Rtx#$1bZJQk{<5=) zB72JYr`~-fROb{(Z1(hXqOY;Ud_lwI3mOq$&718eMGVno*z4?c{HH$NI|TT2P=YxLww~?2)s4wUs_ko0A4> z%M;jFIj*?{+T2^YR!&;9wH4?sXPwE~O|NIOJ}Y}TJEu-=e?gmCo1(G@H5~rPd)oSj z0Au#yMbx-)^MG;JMUM6t5kn>O5Ho3c4OzbTjJ*qj`^>O(s@Ia2ndjdo!eORCiALj} z5iXbiipL1$ZVJJhc&k?rxLX);bwqkTa5N7?S-zOBE-v7Yo|2VHV zdApBqH4_%&Dl#lab>V9A)v>u9qk}5;g9qvNruFdQ!{&yD?nOY22;UtZL4+L!fq}7Z z1N*1bT%!M$iN=0Xz9U93o$0BZf?>#}Sh7p6<}g zl!oJEXXfXGB3UlbK9)B^@yi(7PjSq^-3`#yen{WO5kyS+6c*X_A){*;Q7`H6_gSsB zk(WX){ju{gl=wn-PMzId?m=3eU73LZF5DQ5KXx`m9CH^}NMal2C>PFqs>J;L+lDZV z59A_>ev125NJ3dJi81QRF44hKho-)ycv0y_#c(U^+;Ks3hJ@=T7Mo_RANPNTn%A{T zdFRXBO4ssY(;-&I#Gfu>6yG86oQBIeRX)z(bVFj%k=!i--H^W&)ptu0ZU|dPyIbsJ zL*~(#27mf=#rw9Q5C-0GHYC&@i_^niz`$8u=Y)Z>sc9f~%V-JwaG6H$*)6lWM7%mY zeRuqEbol=C4M@k+!_%Vzt{W46c=PV%(;Jh&rgWT$^!LQ$@`1ai;!2{Gcnsy6pZLI~ z?3y7rNl#|(I9jPxG4-hbjpm?}c$uWj`4eaZbgYs?8vq^uhV^~|bDs3aGRKgcZf_{FRoO&bWrT9nT2T z=J%Nj5RHMy$plx}FDR8(*(-Z`N1UZ9%NTn*-C)bT*qFyq`b1+MhuUVoCAA1AFxbr} z&7M%)k~TkrE?_Vjk;fti{2Qh;_0x#;O3L9b zyZ~$z;{!8ZIq1`kF+XZCKi?Sh6N{;C(J5ir^C-K{ATNk!$wX15Otae$Aa!m7AGPvV z_Y_Ke>CHNzAZjyLJ$FgrxB~&e2S6_zFAKQ!xB?xfk2dKr~G zSaVmbNBUuV9eYD=>&kD<);BA>P#5%$N*!#&#e>zJaL3sqZZUT0uv~{du764E;3m|t>7DpkwVF3A+KYEm-E^DkMC~j`B z8P6^GfHR(+ji*aCl_!==AKKZ<0u09v=!1NW>|F=MqCyL=I!Lz|Yd)&Tc>}61|47pk zkqvhu=G*by@c&MCF6a)kpm*G4$K7EzCO&-arwI)vja{N$=)^CTm$>j&Fm741Tl$!Q zU{5CvSHAmPH(VQwWin$u51zDNxT!Zg`i80giY&0|dA#giAw9;0uf;%<*c#rwpkb8a zbcio*!^h&~VrRwN@FLxz-uQ}8q2AQ`kU*4GU3gx&!aZBWQaoZWkiVJem&3v6tZw6| zfBTrAkt_n=qhPMvMfUzNvtUSc6MMhJS`5Zsd1Fz&e$5S9LM_Nr-OH}#muytiEgLVu zohG@?hR13&8b)cL>7=Ra&F-ubZ&!gzE)|W6oj0P*3?>;{M_;0g*)_#K+bqgoifI0l z7NhpuajAd2J}&fQTA&)#vhggx&sm1O2CaRkq&UdUC(cI8Xhn!S_Ri9CP+(NwKYO6H zGr6LqI40ZLgM_uWYq^!hhy@L;;TFf%`Sw=xCHL4}v%B43ln9mud!m~WU2fr@!EJH=ZA#|h(KfIUQjv@L4swrCB zKS>*9Nv(}JP}axPjUOHh-#kCjH1bl0{11%cD>vW=Bi52L^W_sPe2t}|Pwt6piV6~# z@65y=VLeLeX}^*_O6Q4X-8zGVOVEEqV#+wYDYn4kWllnBP@V;&!h6{hJ$F$KKQIOJ zKeA>x8M!T;Kh%+IvmQ2^H2Ur2&1<8nIl!kn1Xs9O28@yP%o2>T*s>M{hnsg^(eqGJ9XA|%sVY|C{ zsS}@$S8%H^O(`VAoVrw(a2s=%Dr#;@Q^wX+HH)WaN2NTQvz{tmZZg!i3bUd2_@QTW zhBO~Z&A@-9YayF*s#NaieaNw>8B{Y8QFFZ7d@oy2B5LYdSL1T=5fd)OePzpq1}>k- zR^={)sG{dyIAgK-T8aVRB?*7$OtdL<61<9w$9biZY{Gq+XsH*-)}TlODh8qloP1s zZ**+LFo8r!tRMKPc-3%}0U*?6+j~U__W+bVqb4zO57g|U5;+em*B8;{aR}WzGpEMG zs9^#KcwhM;hqL?JGU34>_fiJAhPbiY6HUYgn27a`-Ib^!$Q!7+kH0#Q1&ZsPRZbhr zVxoU}tZH3J+b9p_G5NE4xp*2-;u{wtWiXPccLTKoiI^oJT6`U+0h3J_`mIy0+*Qs7 zw4u5bvGu@1L6@O=<1hl8lE@h? zuJ~-=HAvsk0OjNnYA7GB3nhq(zTO& z2{%BsQG4hG=TO;dGtePb9{%!(b)7XE2cM(L>>(niK6qgE zfQ$h~%a6ZH$Zn5~w0%6FP?)JycKEJs!0|j6mYEtyo4@0e2y70sCD=^eV{R$ruPOaa}{P})ent=ND zC6>Q54b5n%NTu5`LJUcgR%ph#0-ua{mSjrgoSiFUIspE8juBDvGI-z}1i;IP&+)|k zp-*o4nk1YB_R7XzpAbL&)a>1lo#koe?!yCw4ov(Na z83N>(1kc@|pN~uM?2W6$9?##nx)9=Z)~-PT9&mEmeZ??Nu?`~LG!8X7@Q&EP3{)iH zU9p}SCaH7qR$ViQ6Y9)>R5O6n?2LixT!19s!HcoYFs;&-P!=4JbK%AQX z;+~*X_Z9XB>5aURuvIfFw_^zPBX-*ftuQB_74aubw&XBa&DfX=f@yJ;BGZNXOVDTG z`GH#CP2}D^V~6%;W9;uUHcuYhxX}yfI=I7zE{w)0TgsDH7wR28`Do0kgq+F)T`TGM zBDaYCE+hX-I)0OmKe!_TS#YI`N|)G%8HG2!KO;6Sz7=z|u3YfCkSB;dC)_01a=jg} z4qvl*`Rv7w+&$UQHkV=H_BnBtTV)w$PiPoVGs&yH9yT8(`AsYKo_6=YWev5z)>JjLqx_LARXy<|6Z3eN?*pi_80$JjMqWFa%@`OI$T zblC+l>>lv3ev6Iq+MITG_QJ9E#&~QMuPcbEGpo8Fcu=)E!%H{8cVHl}>&yC-OvzHQ zBKJz2tf$;^Vv$>??3DpFFMH1(o`(2#HuPuUSWCxc?UcQVZEI{l#Jm1kWRGMfl6rSWFr|ezoVu*_& z>#~ptL-5T>tF)+ee3*jPx>%;P^md0oVw0%UHT^W_hxmAY;qh`Zp|OFQr7aH&8J_Ym zFtBo2xP>zQ5tA7CQVap(B1XOxLnwv-UtGx+KY0ct!StEyfetT7+p^f!E{fV=Dei;B z=EGV}Vm)YPCmu~9a?Q7{E{r#>8XotCR>>QghvE1*9Lwt#i>*Rp#$7-L@)S3h82D2> z-)v-|n16dN+iRNVxwW6+v&@WX-ZZ!+#Dww7db{W#KA0FB0h|%TiH_g zJdr?FkOG#c3N++FdwiN*Y2=R=g{Lw>O3P7c?=o7&Zl%pu@;6#NBmT^Z)G*TYI_pbW(p?VCfEk5!IPB;ESVDKpW{zNNfq zIh~**$OUa-?ptm3v(-BBgsLyZ*fgq@$^G|)~*$#fok*OX-TS_v2W7n3f zln3*jvK*KA^q5JeNiFH2P*uC<51wF*SHRIW)e*Dq0)>jdu~nb$_Og)(SeXH=a4 zO1vfU77mvesO-F?YrIV2vR6wk4A=#OdFB(D>QT#)=UlruG`qmlF?P225WS<-`?Nv_BzD9TE-kj$A-uk)SqHn+a9!f zO>*HUe_;;2e!to3bjU^EdS8c4{D!y^=LYjA9JBCNvjfSIo>rGTzWEU}&EcTg?Y5dN zauG+XaA-I8Tb))LP%YzNy^118-RTZ`t+q`(cT7`;qSxy6x~+ZU&D=PRDGVwZ!R>Af zK#|8RxS`$d?+-ftCh?-!4UmXVr`2zvH=G2~ipCsQcVG|pZ3a&K;47oH3)qMk`|~6M znjl@9pIeE=Pk?U7)Ck1G_osb$E_Z0K+2Lm1z${w;R z>v#IVX90szG*H%TcA8DQ#b7ZVGj!c%hxrp$cTn@~=6=WK=@RPl3_utLz%>p;W;0fF z`t44;)6bx+w8**6psPcv2?eSDYZ>`aiQU$q!(mc5dV@h1c}MAD;fJhp?A`z~0Z8(7 z%`+a@U7L*kIm@s&02%6axu0tOXgn2l-fA}6Py#aXV|o$$AhR|y$nNwANCrrYY$G5E z17I4SY)Vp5RjpooztbXDN| z5qJQzCMTVCYhWV?3jsOUSQR|acB|jp=k7HPKz4!NPO}Xyhp-~b*fTH<*JHX84HhVv zMXBUld%xdl5+7_=H^kbu+nw%yx7A^wX~ekLZbOW3QM_hl2LhW!h+ntA4<-*j$f@54SswIzB%mNsAbFDs3KsGfbPNgb)Bg zOzZA;t z_XK=_6NWrRuVaHmaCoLDIv|_vri{;(1()e&r*HQmUw<5Cf&~nKrUk$-^XAb`;AVF;+=ZWjTd ziCLR$gVZzMICd|F{bpys56Uc4$)MVx!E-+&A9TW?4IQcEZKn+l0IGfgW`m|Gy1i~6 zips%^O`uL&(406Z;}ghEYXEh@z#5x6?R`)+Z2&LawF@O%@P^y$_sN2~-fRKmPgYj= z2hnJ}M19fQ2enUR+vwR%kfBAeoMRu|>h#)>I9iQ`l7+mXkARjaL;|I(4=ou~E(Hz? zXs-t%0o|`CK8O+&0xD!J?12{asa@!5;%M#i_5kgyhuuU1_EbQ5G^kx@4Sk~8C@4Q@ z&fpKn5>v0)hLjzW31hPhpgsbU88j=#0w~2kNqicH&`uyiuMgr1cELAPd7%1Rs5OlC z4VFnJ$WWSQvnL?DvA3a4p-Q!OE+L_4$lU?dr6Kg)P7`ufDxlK?BLeu6qWWuNV?hrE z{Rl-G^w`KM1!jT{0vQ9-C5`588ZoWkhd!NXEvMB5!S4~#!Gb73SG?aNs~L4uX4$o| zL|F&ehpvTtlX>)28h_9LG)>eSK+nMaQXD}dn*Gj(ya}D_8JL6#`~}12hWweBfNa4m zbSpkFUL0rFVA2}CVL~6`b~ajP?g#c>?~z}tq;=n__NsJpBx3r8 zjX#EBH)-NHyCJAt8t#BwfRZIT0HbB=p_$$GH;`a%L-g_rW+< zB$o)L*;+xWX2XySTupQ}&heXhz;;5W%H=_)l0JNB_wIwiZ|$MgFK{AwKL@=4Xa@QN zx1D^5;;&FT#-o!3Xjs0WNwuTbvRp9gha{_ff~}>ZGSl$JtdcCN7bh=o$%^g0em!Ha zqXBn5@yna>kvMdR+|6GEmgEQ)3sTt5nrpdw53nzh=Dx?6^*^HQ+!M<*>N-5mn% z7;yhPsaF0y2J}glY;ji}4TZP*@5Unmv>yFSP!U<`rPK<(R+HV6gmS8$5l8uE+&T_{ zS4gMbw7A%Bi_^M8oVFH+AJ8&N^(`I#wBF4BoLJe zu6$)`CCQiVzy4qL-o3wV8)+2&yZsbwwr^IHC|Qy(NhGs*9otFV&8@a`_3=-oC0b%b zkt#_!RvdlzGlM%oP?po~v(IzR*={TXm;na2!2lS{RK$IEGa!FZ=K$2*-Pqh=)!>oc zb6N>4a`W7%*(w`mYzn<)w#kSls6$Mq;2d(7!lfF{m;d#T+Sy+7Y0$jrQMe`ENqEf~hBS##Si~bUp_pY9MzWwUGqDt7nbcAVC*-HjgW(x6(ieD~ zv>%`&9bv~->g;JNI9`&i-?dnSJDTleIvZntM`FDIB5EFDkr%-5c_CfFoKbQCQO|i0kUR- z09`d9!vwTY4hdT{VHt1uJ3<+$HSuG7O6(8eZ|qO#i(4kXt`=R_Zee^lPg@se4sBnU zGqiAnlqZb6Vd{+%$a+Rrz|()sxYpCvqvuES9cL{11N zMmSf)?(eQ;Uv$8Cff*KLFv=WT>aJ{4QDhSayB>JMsmPi&&vX=d44j|ftwUD)7JyClSqG{9dXxgI? zP1}q`lOosvWeR!fxa5I%x#XB%GcrcKcRBnaj&*2Ejxl6EoUxb~V`4*o;p3dKR#m4( z*oiII^IFzzA?w3js46x)HcJoKkxMWEM7@i*J9p1~boN;f8z=_XlLq?Ctn-Hx=Mkl)Jrg0J_yyQF^%{rA}(meCmzAyF_+mQNCEDxR%A2PQ0!O@ zT=0wMS5)ORE&6HEdbRiR@B{>8vUV49G>l5l;Qmb3HX8bpKLJ_aXlOCNi_uVC0E@hU z?E$_!^WQ~mjfh5}|B=n;EB3w+`Gc^rn8LD&FF9F|deo$k;5kTu=N-?3d?I23baEQMtGD%IkS!%M$ig0iCrQS1*Q zE$)*w@(qkWGm_ED`ehhLc+ET}nqRqUC<+pexM~vih>AgV?d6cjN%#bZj*3I=YKXAu zRYN2Y&l(a;c-Ih7zqEhyi(j}cc2;1cQ7W*o8Z4zT`{{HR#kkd84(EB1PJ!8svtYU( z3@72gLeu+*fhPA-2( zypVMM34-_XpUx!69l{OqXcZ)6!ZJs#--%37M9Dl{s%A1+f%)16vSOl~+JxRF- z>RHTb$n`=osKFzJL5*cUF|BAMw_4FiDy(Q=OR@1xzIp2rl%X`4Koj|DE}m%3#}i;> zx%z%Ikm#otXq3&dqC5$)?xd_Oe_!$ij*QNB!7A@`Mv$q21>GTJx6jCzukV|!)w zG~WWx-&aqgJddu#18Nr3NaB&c4q}kQ<8jGIau5#`iYfs*S^*-(wrS6WB$kx*=+Sj4@R6-Mq!!#&# zED`PNP$pKz@G7VK6?kTbuwL?stwd>70un9BF9RE|^Q%a<6s4wBm8rt`E6`U{@rs#j zFOeV;s>&Ateifo#vRA?-3b$5lk|LkmyV43I<@$Or%Xr^_8l9;p`ZfgX@Uc;1EmBRb zE?b52S7u?QCP<<@EkMpO*rJU04Y(2_H-=o50Z;cU@JboV*3jaNHqg?13%IquQ<3+y zl;f1=Gp)uhhDrt)DCL2Xz6xM(cNE!`in5?tM;7htK-L_I7NyLQ2aOzgw66n|*bPrH zmc>#uuTHAeCACx}m9R;+H_JxpR3@=B~sT zxhpAt33O%dVv?1MQIjglQ$hS{`D9*-IqSR{@L} z!FHz83y{MNv6)8tDuk<*Y+o<+G~WVWn*KDoVqaq<`Zf$j5S z6~#_0m)i_Vd9<%XnOF*e)iPvJ5*&-$rNsh94n1{0h^X;G^8~;S(%E2AVL8>WLMxZa zEo`b{rjhDfaZ3B_=&LbpF~%2Zu6f`s?fxa|F}MMxNw8`Zf$#zqNr3-bGZd z;rBRNx-0K=0Q6(R$`SNQ%CwsvW+pE&?tl123A+H=rN=k?I!H}&%U44pPwl=)yL&mw zhCt;akQKrUBQ4$4Z+`&%Pyxs5BrV;wTnYhBq_mm1aVkT)mMbW=yY;)NGOTO4sw&}& zJFGISTXm&X%0$2Ls=#v1OE4}diwNz6O1UgE!HhX0FV2`f;Y7VlGeBJ9Y7J2Sq}?HJ z+jI!myn17XeiJ21hj2?*b2TYk-*=Ak_S`pmR%^zg( zDphlkEu%!Z<{hHw0p(iJ0CBCijAfF={i6-sE!{{$27^e$#~Vo#$}QhomJmOcFh5yP z@p7(=O0MimaF%Y83`vVE!5Nm{%tcL!=NApCoR;Y)8TwtPpuo5SZM&6sprRPt{b&`E zTXk=0&y8NGR-lL@g(UnEjf#oc9%@2|ohz^yUkBimG{`3>rA3#=`Wg%u2ZLD|gGKr( zglcWiSZn1@RW-jSFOWswD0j+j^@N7ry~?u~$%aJGHI*Smriy-qo~gX4)?w8vY%x5_ zci3`7S?;$vo_WD7kV-e-9OFwwK>|OQW3uHQE`AhgN}Rhc)wa&B$s% z!pz8OKdZ2InxUyKo3+zG+93UY!%%j6pi+hwpNdXYL4GXKa-juv9jStUl?CEL4H-&O zh4?g-r3&$BQ<^IDuuX%i(8D%mszMJ}>Qxn%NK?cVHnv1eS=p*k0;b+oA-_#2u#n#+ zaj#GU6*^f(DXOfZRj8qowpO78?22238Bb2 zrxry$I@JjzZM0t)LIKd279L@AmKFRxyM&>4G*|{I0lNmNim)e69L+h+U z<*X=0l~vFRHB{0@E0jPaN_nfxPlm6fwmGU^z-27I&0eJq6IXqwADz zC{$Q}bt$9RvAP){&b*QQmx*?^?ia)I8MWWB9z6T4M-NR&maBDIgwu{)3gu#Bg1Eyi=TKcZhsv5sZlUq7(O-r5tm?I*9H;hUL4U1XSr`%Jo-Ndn z(Zz-M)H=FgAGXfsHP>TZqx1QfWegNr&^{mvGsYYqh5W7@Cxs=lV(1j5sH#y^l;h-x zLWWAYK7W7klAFAKmXnW@g1tGIgk`%QxN*2C`@L}8Vv?m_i2RI~&4;RkWaCvv&j}F8 z$tUSN9ua5I1ZPAA0$^@^?yyQn6th8llRz@#51wEdo{~MhSgMK7A>~mq6G1k@UR%A1 zCti#azEI$5mZqNK(vLZ(I^%CyW^;1Qew`Rv+Q8S}&f+u}?FVs;&S_91di_-aS8Oc3 zCr$JLuB3hxP&4 zJkf9cfi;bDjV>z0r`A`@SDM*3g%VJ^si41lw-o$KzNA(>(bs*A5HG2NWXeNA7{w<6 znGV^{ce8#joTOu=&Wc73QYs515HS30L&uz=?Jy3kzO{|&@!eFrgIuabHh{re~~^1TCD--JrCKdnV}_j}0x^!Jk8Rmpz87TKHML-zZ>m+VbJHeED~X=5&~>y+o+ zHnkdUUZ{xai0Q>RPsy*q-$aR*V^scq#EBT_>|7=Hy~Qm3zmZ~)WFRX0yDA}KU@*{3 zh1_cjI;K3#h1j(%^N^x+(NQ~)7w@y_Zl>^WI9ShUO+2ho)*GcHD$0`R9^HiCLRiz9 zS#(3s=$2*Ql#Ti8w8H*6jR>p&lcofQ$+02@p!n&|)lk0r4sAvl=?M=u-rFcCIy+p} zqy`pQF4uROxj|z^=Qql?lQpv(Gk-ZMJFbY_yl9$H~;q z#t2n-bW5NZhdhoZN@idl7(7;6C;U>Ip^3G}*Tde`&?V*|dkTQGqj|)d&tx;ASqrhG z3Q#*F@y#NITtgxiO@CILW4SAAN@%crZKQXcw*1-cXBm|uPJ(GQFo(DX`u4gAS zZEhlk3BG{lO*4KX zt0kNz_BCaT@)j*@Dd#D8Vcyq0n#dd}pC)g^OD=Eeq4skaA=0;v*l+a{%Qh@?@fn3y zwDu}oExEuJfbA7Ord4Z{S8SznvtHFsqWNLw3<`T9(`&08THCNFNKHM5_)WN*RK{S2 zFOWWm{5%zn;b?G-o2gxuai3E}iz)n2o!f`CGWb}X!N;{S_*9+2r&}^0Jr)PtxtW>G zDN7bEhgN1rREF#sohV7GvWV04^Pb8Gqo5_?U{PfUdTiv{vH}>@Kj@OWFfUp5yKRV} z!*SfMQ|!ISg+V;Vc2aeCNyF_$t!r51TMPX2)#i?@#2hp(eUI~pd&B}}STYl>IW1-< zc>L0tAKnQ~74%ouXC8|KAS?j7g4Wk>-`XHmvNH`^*&cF@*C=#vy3|spC|y|KI4Ib4y2WoI`PtP3DLhlU+g0C$Qsb#h>2u>*uS z#9LVIpz=-2d7Fn$OI&n1K{9gC;D3P!^H^2kRs3F=@hVK+oGkov4*WZZmYN31Jcu1$ zANaU#Q5n!OU5E(};#su`;*}@luu_CkyJQY#%m4x8)XG zliY&qb#iliwOfGJq>L5G?FL)O`WzlkXRx7g`?V;46}+-GMC;o9_H9M-Vs-LY*Ogp= zj^%&eVJz>{*pUNyZ9sLLNpKZ9P#QIYlee7HN$5zX=ZJZTCT!y9a~Lmxsg%(E>2WL9??4nx*6pWd5tu-|*aL;L-IPD_T8$HCBKI zu>#2ovfZGcNmh^&?W=y8SLK!7ffdlX1>1Q##UOawbf?pdVBiF|VZf9wMOT) z71RzPqlup~YKOa%{;-a8AnDoBIXi5O#V5;t$Py;(cf@{YOh3k(^N%tA7%-42%Shwn zr8FqNoX^BVdTjY%hZDXw!0!{~`=$7fIm{HlPn7SM{F{1LIrWtTvi>Pom!XfLPW?0E z2$iiR%X3#9k=}{VF=23?^c#&M&RJgir$CCg=f9*UYui!{(h9P%I2G4=nCkMnO?uqNV@-n67dJF32no9v+V9<(Dw;(9kOYUy_akJCw z^n(_^P&$9IheftMym4mGy1)-vlg)PL{TZ;=gr8;1 zJZd1f&yPvzD9hMyzfGySAHAM&sNcp3UKBsi+$O7o2$$Z{#k8 zmLs`rWUrPONe4R8S3W$fPSg3eSMNe9}W*&iJeNehu zG9Osx@_}W3mYxIighi4tYMqDU?r$lMoGphXD_(A%VYcM?CU4{kbmhn&@~)ihj`|b1 zgPlQ(PtK7&Lo4GZo1U}JfpeIpLZ*Jqqs`0h>J6~I6`+zBr!58AVxK?%?5DeNKb5o% z{QxUMwz>4?bja5JA=5q{wzLaU@$@XTsGF=ZeQc@(CKGGvh&jIDLb5y5X$Ho;^>Lp_-uHtUV9c0_Ayebg)R#+r~Ml_ywS9D zU%Lb%v!SmT%ArVX!qR70;W}zPvn(xA1gHL*S|EwWHHPUfD{qmNn#EYNM2@87EI#iu za+Le|7&wkFb3{^IaZ!A;?9&sVpE_p7wn-_=vZX>vz@(L}?g)ndOis(u?yNtOLw^p_ za&+FGu-Ryk=q@Mf*dW!Ic<9#^W`JyVQ#&R1)P%KXuxp*dfj&A(zDyCJ`r#gs&T~s` zN27eWrKKTcoHpOkGt^$n4pXIFG>@JsK??mqy`aDNeB9Ixx`QIn_v-qHc?E;ee9Iw6 zKbvrgt~MaFdJ^^`H*}>~U)ZP1P+OlSus#jX`{mum5Ct}#r(B{|tWQI2eZm<4i&2KT z>q6;>PXxX*VMBj(Hal0UVVzpQtR~B9y{qDub;(?m=t-?ul=xAtbi5|oMyyLCwl0m> zx->G^B{AmJA<$Qcxj8&i{+yckU92GMvnBp%<;_eia`NojKxT|xJE$;Y3}rL9LVeeh zT-HRNQm$_JGu;GVnLy_Pqxvp-@l)_H-AvqE9^XrH!1a@DSQFPyTg7gn-uoX zD52rf1ajhpnaj%U=NlvRcN#qYBQG6m=YcnId)5SUxC)bag1SiLl;@9J*{{IZ9|n1` zy0Nv1!(Tm8)v)(z7LWRdt?1O87++#zfra2P5Kr4qV<9_i+Npa;FJ!zd(7H0s1T?rPk|R zRJW*oN-1fX3;CnXo?3}qtu~)hBsj4uaH=%ssFk6C(Whbd{kZFvV4vzQo`4((TGA0v&V3x^cpE#uD z)?!MJ%R#p1b8QTBZQ#%NTpRBW`eQlQrvB_~eC}O>AT`zHq;v07-eXUhFfymVu6HQa z_SiMLbgIsP8&j6RkQ#G#DJl8D!awy6{KNiY_n^N}j-kJR#6^yp7p}K2zVVRrNQUqb z+W!~br+b%P;Xym&*_8Li+s8YWoahW+2E&llhZ1}lr%?7{V-xj;F-@WJs%epj7?TJM%duQG|D(ex{&x(g1q>q?KQMe?-268lHu3iln<+FRj1w3pQ>}`Bad<43 z;`V?9P4H4n31K@#}p1M6d1kF|C^f3WY zFE$RB$&UOJTN@$$lc}JsF2b(RPC#{;MS1zEeagkT+Hf}{E7!Mg!(T#N$sS`_y&DeQ z8+t?sxQC_FU7VK^>9iLq%>)f^G?N#5L-!_XmBqOfHczf+ONn7OWltHx_R1Ch$(2s| zkOK}R!XAsr$rHIvraP@P!R(%ZggJ!19@TzMCC-QriwUaIP&l$K&QerDAE^=`sSXS# zs>K0Yh>YQNRw8C)#DE|&b)HqYfrk4Auc{~(x!cD6WbZ*-JOLAl#^rglBlhnz|0d|A z-bD{{rO-X5jG{gAX)jr$(fg>HXs#J6gD9fFMDl0walu>GA8}!F!d?QNN}E$-b9>u? zooxqpIvtQIJ0MARK*H!4n_Tuf@fQZN_pa=&`O~mi#Duc-JU91vDi;-$LkVhos`s0iqwSshWcHWmqOzr--cJJ#w z?;cd--t|4N*}?xOFpdik83pW*bO4dwqyQZP00|tZ1OF8S0(oAyoZO`8O$x9n02UO8 z0q|+NWu`X;K$Ajj%PW6+#1~t207_3FhWG?xrM3Wtn^eKguLR5pDykS29oGil6c#nY z=e+~Eq3@O0zxn&He0=ba8Xf9MxqzN}F5aHz z1y^$6l0bpISnPg)KT-lXEc|g%-)nvra8D8LX|eko{E=`U3jb+Qf7yKB&x^Ccx&NW4 zpL*~)J@*fb`XPQ^p8J1#L$(&7r|=wogu|b&u1AsD45Q7!zx>jE-03y(V%mx|qR~%_ zjeQa5G{?mTtoudL@H@+;S-T@zJ05+A(TBzEKKzlDfhx`#5b;}mTzDTupa!TgPCr7p zc8H%cE-BQ=al!BUo+7@7ntLn)LLW)^dBfjXrt+9`?mb7{w0XmS?#&v0fe)Z>HFBn~ z3(FaiOy$pv@Rirl!F@OPfvTL^pQ1%sW`3(hd5XtOfO;%}^ArJ~L}*OMRTj|SqFSWf z6)yXR4_iniF3z=-grq>UJQKnYzRRHE4l}aX#mhFu=z({ZjmG65&I}{B04%dCy@`IXbq@2)0wu0~u!+B8sk{$Iqv~(0x z#^{H;5#J<)a;79c_AYjl(swz%AH)Y;egc0iMMZP9DCO$TQdB`_4wfR%?aNud9I9Co zNlWdxn#5re=;NrB&WqW+AOq=S2FrdApGJH*R`H0Dvd6;oGBqVgfq#Qpk!GKxWGr)F zNA0JXe?w^P{T6woD|?^AW&bM3U>f_sla1LlfE|MC-2C{%I393u(DBhL@*h} z>3~|i1a$1W-Wdu-opWz~)jMl@ZT#rauccyXp)IgqVO{AVfZnRF!f?dZw7BJjIFH{k z6Mppi)O1R4M+2NjuM|dvr9TTTXbcSCGldAb)C(8d5G+&Oa?cfNh`re^`8%hbCF1*`o`sR87pk+U3DDe9y@$%478zC`juFTg24UTcU z)WfPP@X`Xh4;&;5jD?d%-t)|xs3W{}$wPjZ&kT&~GQ-M5TL$EuBT8UJI9cRHIQ5T{ zH7?EVl<~Wua*Aswh$EQs?n?Tru=KJ@6)Q?n(gGclsu_&bDsF=ib{>|hsR;rm1f`ZO z>6XSb66IYRD~H5#LoL`vYDs3|cb9c%-7Y5nK1rBX$ge4X9rjzQTUP#A%9kfY;{LJ3IIC+RSVUl5L}iYcw_I)Byk z6p)^i1BaTsQS?P~#A&@-C#RJGNYyoAU9PI3$9iFMyGZiDEXG-#mkR|5_FqX0W_fsd zNr&3g*YD(HF=(qQVMBB#B@c3ck8-48f<`oHUD{WXJ?M1=GAGTBy&*2F%GkKSBw7pN z*8B;115%?$rLAq_Vt*BH#)ThIA%|=4Nn&}{*eo`lpalny6@puvI~I|wSp=^fKHwC)KC>`ezkNc&0@SUC z;_V6P+&U^?H32@?HMf!8K7T}`)u&V)`FJ3Z-Qx{eh;~aqYe1OwM?K$&y|5`FKGu_s zp_kVog7gHWCK#ZdurXX}8eNj%5}jBSSt0YHo^Gfdjq#i+0S)cBC~Imh^Rfm=;6N3O z6|vgbC9bukI2(i_h}^!3<=S2?dWB0@OV+2Jh^33B=wJ~~*G@i0Wc($MzSLsrN-7pr znZh}M!dxvQT!0g9P+nI#2AVGxWy#BfrDsuwY)P zsH@sE)$T3#=NGzIm8l1&Nrm98DEX5?^fH=FgV~GlDvaf=6cG}C4r|8|5Q*1w_%t;R z7I?)$H-F^Y<2vFsad)0sP_vb&nS6awMh#Y?22yRZjGC@QP34Vh88u#s8oQcx1|4;{ z5_QOVQOU=jlxbkVybE8io-Jf?)(I0C`L+(whVzHHt_j06~b2 z^jJ-Y5~XhlsM2AkR;j7isadX6Q?He+Qn%Hqc}u05x7Dh-qFU0CjpoEgPWx8XSn4^z z)`K`2IdU91IZ5m}_Zo#;F-qtV^@f(MG9S2#%~jzHU0Go*h;*{tsLZLCcqQi3%a>F! z!aDweYnM+9xRkQ);X-A5F&fW=UXeFB*XNrzqVM$eyDV=;WB2G57dqx?fERqk7J!IX zDhWw=(0rY7DWtCk@EIQMlz}hYhql;DO_ojGuS_AA2so}ZA`=)=ct*`uhgyh_(rsWJ z11zwEbq%o84z_84#dfeQ18j&>wyJ&uYZlu^786@ZBX8!-F+pkVu~HOyGXLh~@!?D5 z-8@~I7xDn{jb&+8)zP5r8{NrM@9Z2{w=|UTIPCoqd2}(ip^KwP7)$JYUhE_;<7oB~ zIvF=o4)q{wT9n2};^c`Xi}!s~V%eQnDV5U3Wn$5rx><68qwwU(N0h%0FP^3PnIPI% zzSRswWbZ0jqJGFBv6VGMgHq^|j!~)bV4gLR2t(yXcKM>*R|9vf|MABk;D1*^wm=hNSK)BexzZ1T`wRq=EEcWt+JU5v zqRhhpjF>Hl9=AGpJ5R8G;3urYf`wD#K>V_wWYETIddF>DFTUb+JwaYF3badqnyo>r z<6B9TY6L{lfGHX9?0@)2lnmqfD0Fr&!f})gXbb&fCbI3DNM^LbpWi+GK8H6e>kKCk zrn5NAx(ANvl>XWcF9{f?(`lOgvZ6IuKZwRqn%itCQF}n@G78_m1Dudi`1Y!%|PPn8*Z&l6+%w+LO8 zi#u{{Bq#c{o6#YOdExbH2>LR2zXi{~e%00TA z$G#s#WJfHct`cejIGE$1AZ3egO9+91t8!sK^#b|aP`r!v0{OmCMl!D}u)~+Ga^yqn zvceEoN(x|q8tm@$1EP&&uJBYXAD4KVHO;tR2F!#bk%P=!&i(Fo*xcreX8trCA70P8 zc6X1OGulF^I8aZcq3zPOiicHx&F--bdur}W zUg3DY_Fd@75LN(FhX~_X?a_nIm^g{mJ>5oGn&1FdFJ;oPY6?IgK8fd9hWFDsznYP0 zCHK2B$?8Z~DY=BIq*-y%M>Lx85t>t!Sg11Wj0OX;>lz#!zB_&W`o+m$uzPQQ@BaOA zyz%}UOW2?11+WMbzL#F)VRi-WcQXo$Ac{#BE#0+VMa$Zo58-7us8Gs#c(wWlvf5o5 zoQe*;XP^nK8spWywPy=!bai(Zw%Dp6!0(>RDej74QCOoZ$BN>^*G$6pF-MQlSf#;L z#xR(1m_*sfQWdsBmW}^Z4mL@c&|n$P&1Fg~P$ffUf@5pWh^d*f zJGdfV!|||iG;BDf`oF^O@Lk*tTf7Og{wUZ-l^5X(cfkyaI18rVHdnzc<<5?R@8B7g z@-6I3noNga?yKfB^pu;W>g=y|L84m&GI&fQ92O89U&wRSJkKhC&#TF(Mp3IuboJXV zgK#zTcy{M~>lTBq60J%+p*lPS`z9CcY*Hw``I0+(I+P0rhyFjM-xODgCFg-AjtivR zAX-mawWBG$iu`YP*hqV@_J`?KFE8S>Ne2`*yn4ahkn~u=PD*tHx24f%qSDj4em(?G&ose81OW z@!I97E{s3^+e=d%RR0w(((9MkRm*$-?=Npt^<-_jI$yt2?&{mx;-vg8eexZ}efsX= zy5CdW`|mF9yBvj=oq7AKi}{Prz18X{{-?F*+ueNsn`o?d`+X;}_2{*{fdAK3sM;&| z-%&?BT6zi>`xmA_V!FDC(=k`Ns20k^yI*G?KJb<#z*o}(+@X@B;_By16vxgeY)T*w zL+HFGw;IZeT-a#$lU-%mS3KqAezLNoRHJ+SY*&*MiPb%3n#OFaypf%|hN1EmyB~2+ zT;VmInd%pNkH~COV+UeMC;Jdf!kHx9vWHj$UJ*apprE%OU$V9EZ56jq5><)vFAY0> zSl4q-$SGp<_5awhcf%2SMl;{GEu#jvLr*q;&*+Zj|A;Xuh79anS8Whclf9y?h+TNS z1g6p6Q%CEnmSV?|AEG-vNuOm=5mr4(*Ai{FYMq@24<2+o+u~$=rmC;Tvq|t$i^}-% zDk}&5%|hdZ$(%-u@^K@?)YpV|4L&t*d*AcMnqI-NYXTBb2*%U zVaC|rIWLK0s5cQ;aOFmV4qmO*vI z>D+J*lFYW-e-lY#L}v)!1+cES34k=I(ku}y9;gV{_I^TFOeJ7$afpCHh6HS>8~uF~ z8McJkfB#&SESp6B&mhCzBjwvnxhJY##83}tGj6@lL#ua01&-T5q)Gzo=m^lhH_e4G=Mj9Wk&tPh+%P$= z8jaGdF1j~wBlSIA1O;z_3)pDwNK?^A@Wj7@m!5sMAJ*>zE z-o2uhLwl9nsuO4K`Wq%;+B;OQD@qhqI|!k@L-e04@P*Z%yjONnAAAlEr?Xp?NH{ixgYvI@dwCQh9SUSy#*BYR~g`ZKXRnr}v5~tfJB+zRe5v zcQ)E6Hye#v*T1FRSgEw>M)|t781$*ci`HYM*AF^L4E-!^{^*dZ7MwQyj4br2X}}uF zU4}A<)f|6$B4}_bS$g}ec9LU4>y**UJs^0G?H}lEqH>3>SBp9XL@%vNbr`HhW&Ol) zfw>W6>PAC%3=!IWU24xC@}ZAd z^bL}q1&#E4g_{axGr`HAlNBV_x$3Azo7Qtx(9%2{C@CcmG*y$B7HXfzV)B(UAc@)( zB)W^5%$&1~VEX+;JU+Pk(Opg*w3KFkMrM8#m$zq>C(N~$^CMDm*~&$xX?UY7FI<=e zyD8E3mVW-Sv*5fRive{s@-r`HigrG|>ZX!8uwRjn-(J#tWMz0;X6~w4UA0Qv*${PK zj8DJgTE`_8heM&+w|X+=<;i44v`nS^&QnRwl75*PuHcj8E?{16jl3>r1+1V7%kvhg zcP+Q8*&4IB&vpJ4uVwwAoVe(*ENJ)%`YO{*E$D8K3>Q3)JH1Xb@M73`6n%7s8rM_Y zZDxLx$CpOG-k$D8&IduZ+y3?~`=vt-kQup`S|sr@rNTL_vEiAnihQ96SW1VDx3n&^ z3vyEO3lNpySNKbNsr#=|HC$y1VROtvUPpwRs(qrvy}nf<-?4}VR#S508n2}Kc(fX~|JVuec2IxG-kpvwXY1~yp$PqELo&bj+H2yC-J zU@RBflw+mpoB18GnGesBb797lfI)<7z6!vVs$|*=UkV&2#zu+efkU>B~tv^n<{%}Z@ocnNla0p9@l z2EaD}zEOhjmf-_{p8)(A;7?8X%`!az-vsz3z&A_qTV?nZ;70&I0Qf^4K4ivya8#IN z0a^pl8i3Z&(S#wLkQve`qo>};8+bOf3PUwdvw2?3r>&~7bDNo(P#=PlD^pWlT!W^3 z2*PfNzvC$E*JQ2pt3vmNrT8KX6*sN@u!?~2RszDi5U|v2fS4=WuZh0g;Z3c=m9a#6 zM>tu4?69g2M;@)hdbL_4|XtZ1ufosMDR7&!lF265xP&3kk$+<;pRmzbq_#I0z zU2(JZm4;Aad=li*utIOBlzwN`p^{Guj2HsQJ@QKQo{anh8bgo$FVGW;71su_?$Lk~ zTJSG})IxmPHG`P_K_(7)`}`vlcVm}1cS@dQTzpFTVM7pWa?~(g)4lj!X6%zT^D}blf_#J5eX@ zG=I_u{#_SU-3{z~0Tq+rc;Vpi4BK!-BCx!WHI^Z~lHwH}^pqKJMtFZc*beX4Vh z(4`ZMd-%{KFkpd12$Kp%Y%^}X=MWYPl+=TWY(xU!--?4ZkSuY7$}bqQ-GE+s@%fRX zsELZ@-@csy-N_hj*H#xy+okQUC>`$|v!&(_7}{A=x#IeLk!-q(sZ_!D1LW-cRcRSs zO>q`~^5<#FrZD6NNU-w5n(zLSaQ2c0Yxo7O)}~7X(yu?&N-A|+A+M}aCk>>mD%vBQ zrk5)kbix%g4GKT9ntoj*Y$D!4t({&8REVc~;@_dxj@qSMQms;H|4*u~6Z)uX`d?C8 zXY)*mqLY-1qPY-7GyNp*W3;9Onno49XzjiK@lxntmVIbD{LRu&UMcFKa;dt`bqz~^uuMGQMHUSG-RBab)BEfb$)o;IzRSj9<25K@$R5MmP^#sA2LY< zBw;(pAAtno#c?gmyeTZ>IazAhR$UQAZY6PaR}w4f8FPBZCO!X8n)u7o1hlLoO{iB9 zFfG(&pPu?eR1JSOlqxrr+u|gO(>%=S<*0y1yUwwxStQKk=T%Deq?qAu&SZe$FT}Nj z*u$90^+Qi09|wybeE{(%Oz+g?diP8KDDEl%1WR#9^)*`CJRi0AU)G1S3z#-o2&L!q`m6XyV$GtpV3!XxD9(2-M^2&KSyrqME?NIIJ5E{YH-<^ z&U4~HIfQL_m^pN7PXM1%fK-b-0h)$UOw(Yio+u9@Cq6B{miTdmx4?SR&ot>@sFo|0 z^JPUQP%YV5Dy^n&zG0s_T=LbJn=4M`qlL8hD}P2L?3_wXy~nXg)>Zeb6#Q{f46^Vk zo0?=rSW7z7(F!x>dyD}ZS*V5qOXXSM72|YYaxvP*p~aLqdut(IC1@^8$o)D$zqwcP zre5kUPxF7?OFZ5Gc`si|1+$GVu-_2=rgYW1j8oK3z?EAGgP<|=(*~Ya#PD|nc&Rr7 zyckxyGrV{_!)wPgymM5ZL|>v_+U}%(DLMM7e_5Y30|9b~KJ9mh{X+?|@DJ;wX4W55 z2Dk8hmBNxcbbnDJnj_YPIuG(sVwf$KWz-_m)?T> z)-Lg+;{d)pBJ_oYF8gy-|$`!rvlyT^wSYjAPBhNDNeIYw~XHK0w7Qx4xNZ=7- zDLGE7r$uX<&5O;hM^A83P#|OS%~8E;ohZj3AFP-sQ35>Ym`KYoTT*C09zqrs7J)Kl zW|K(H7nVwFBxW=~z4F1j2owq-aMP174>63+B8238hBx_Vc#nUExA-tka6rOT>T_YT z7B*3#$m6<-WBycF9$dBigIz!G4{-SM*eS$Lcm1S4m4o`y&l=N>q#nSKz4k|S@ig)h zhwXyL;Pc2!lugJ$22f0de_zqPi8|fJkPD`7gfJn1TZ|zO2rqbeLZJZ+licN~;m?*j z*^Fu~gAeMpgdDADvo$ezMPus0{3LS|pvk;U8eKXg`>8e?Q*AaH(=lCdI>u{G$Ke{& zaq^#-j>jpvDiPxxP4CKa4k2xvWBziSi&PxvJV3{}n6WRi)e9L+R#?e)JZfT7%vO); zth2Cn?$W*LirJg-iL0+}p}D%zxl871j-PC%X6hskv`L&UfpTRMD+^zU7EWYZ*V7hB zd6Xx1d_g1ics2V%ADckooW~6?)k9{#w=bW*F(=MYf#-6AK7d{zh)*6s2SlrJ0gQ7a z>|tDT|9%WVj2aMI7U&FcBb0OQ0I&~s{jh%^3;5z6Y=r$0%=cy?*+$;@QqNq;G=j!q z9p=;s*nk2hV!!fOgss43%R7{W*&q_^Qs~qe>B>56<(~oM3?OF+$=3WYjfK}~9=hHs z4WqjIk};!GcWGlTx+oCpqQK}cS0d<{U(Bboatu*-_BAzj9Z1BTVgrwcYAi)&hC9$q zf+wDm#KDkgOX``aDO$;D!jmWvZ7W(|&qwsZ%iHc7!sN;pQRR5S*8X3jEWE_IBeuUH z=7p(zqotIzaI{p5I!+uAXDJ{b%cu0;e;0DwfVW+f$kATNZ*$xi^1DLkhfRS(d{#|_ zq8z7Aje`DKXGdW~=wn}aI$&Y9JT(e6R5hiFa-2S$3jSrzsX~66v#XHbwnqw9MH;3*K@k$L4UsK5X+?acrT)y7qZpm@(!& zFXVUSgfA?S6+ECQMOCqbq8wLd4TT!2xP2sR>-dgqD>-ajv9N0CVpWB>H^J~TQg%97 z^A`ATTp{klo$t&*mAVyL@NSpN|G{bbHw|h&qy~2#QjvJ#TREx>kbD32W9W|K;=g~l zixchP3Rm2vb8J+Vg2lL`$qI3+{DehFM_sr3YHqSBIuxi;!NMGH+)bOpA*iUO?M&#K5)K>BvlHTiG4~$|EZyo?x*j4cDDv`#ZEzKZUuJ1m z>=TnN9U~Uq-QtuF={Yl?oujRjcPf(cL|V@gq1g*66OK{4RGe)Osk2{AIf8bTr&%w7 z&aESH7O{OUQF2x? z1VIP71i+94vKj~Avy_{#Sf23m0*@L3sxf@?V6lPz$whi0CClp5H#?Hkx8ys(^>}&Isx`Z2TAbHfS?HG6wX@KjN*3BBR(d(hyJ&i! zY&FodK8eC7mzTbMOHc``Pt2R)7wX*Lub%-=q$QN!@VYRj)>}~$V?~*v>P5g6LU|gA z3r3@wt!K_cw9X8)C?*$pqp~!%5UnpcIk9bb%Iq2-oy{4V7RA2{^7pIj&284K z%Ii|{7uKbDEY9;s(x&H^VOe7fq^I2P+6+v}iD%PdRyQF+L{1bTm%GPcvL=qH>pAiI zHA}zX7U#ywhwEE)cI`vle^J;%nA8%yd7~x(U30}_BCWZK-L~_QlD_y<>%&BJtyWx= z*49ArELHCHPK=gEJ2g^$sflVDEi@+A4L3_$z}HzZNyk|*n?yruAlm4UG63tBuW35v zvLo_6^#&xoEV!JVkv?X1Ez+5^>{%3$LC!^6GFj>A7JLS(mU?;WuG!|44)UWCQ_x>Y zQh|RpvI_R0P)A>VND|5052Yyz@}smzL4T-%8Z|&;xu-)IX}t;Mwb#U-fo_FE=Bk_F zB2hPC5?sXL2z@AALgIU(de$M|&#C%Zhj~o+&}*}=kMQ+{0Wux64!8S-xwcrQVmOdU zkv;ET5lai=9ZjNHk-W#1xR1QwNgO?l%9I#N(CwoD-JvQ?rnJ*f<#v)a;v1pLjH?oa zpjVT_sVRnd2z0a zMVX3dZV^wJ8t)|;&v={YNtr@e9P28@3TWq6`_q|a?0E!s+-YXXq)r82kU z7_Op*`*OZQgs_PYd((?3vwDuIFk%JW+`qw_mLAMFyw>U6 zh^KI{#CtDZA7Bc7C1<2DpDH)Yr8Jqz=@cHcg_TJ{4>$E{aW(R|CUDt98vAZ5w3y*R zq!Hge(V}6eQ@}n4eKpJz#%gP!i#99Gf^=0iwe>=`7h1($E3u+bpb>ke5t7F~8!XtQ zL7ko|`q_@x=E~OA0Fqwa`wg>0A)MayoVN*ZFg$e#M-Ihuh&flZLq+(a=&=vS`)N{S zX&lpS4F!3wUJ~3=4j#ZZ(p0YnK*lbt!KW?Ge_DTj3K=Cb`ipj~s<3 zglRL<=V^_ySr6@);%O-!c1~mTziZ&Dbx8l-V79sh=l)P3G zbVXv5*OdD`2@Sckw{4UM;!|GaW)Yjyts=x1uq@=>zaO>KXR*vlPmMU=_Rz%UPiR(> z{BkCk`B7^)iQ-WfCWe*jl96g42dz^RiXaD}P!L;`iLw3KI1ZQj4LR zCQX7h!fec=AlXMzG8b$Fq&kIt8Zeb@Bi{@b^`a5h!$wk1w6k5JWn5Eg+?K7;c6(|H z$t-~J*o6{#E(k{xP-7UHA>2@M$CJR0>wfPkIe%3s#jr_Kx}2tuj5Se=n?`5HB$MH*p^3zX%vXl=Irz@nJ`cXPmhZkB z^H~Mvmb#{75(Od7{A|E$1#;BGuzUFIKmz|_n9bO%ft z$1(p^f%yn_U+vZ8{(Kiyo!(#Xf~phz+g(suB*!gMJ8q`~aNS#w!#g4KSdKkq{3S{0 zZ=~lo3?o=-#1taILY)KiA;rtr#A6dZW5oq)7q>KDb%TZ zE3nphlUOjjR!r6qC+Te%TMQ$PD8@Czytb9KWh*Ni-Uhk3v^DeRB>j?zrp2uwv}d%$ zhQvU6=?n&BJ2^Nwe0Tc#^^23iVE5kq-u?UKc*A1|ma{+43y{i4_+A!{BixVP^KPJ5 zgDCESgm@L@&{@5!bh&ihJ}dJ}l#J3Zw453Zw0L=g$GXwQ_j|{$j$S?MIWOs*CiE@y zB9l9i)#)S)!`2_@*A88XM^m~DZryWxX2$+i>h?G4^&g$O^Z%nwq9hOTdmjW^gU4sg z!Ck_9)p6LoMs9aP@&l=`%?tmW!`^Q%iKb-xP4seVx$q}W4!?Rl13bR_iSGUs2Q91e z@yJo-(!;|)H5=G0VyngmLP8Ka03XV{(7K+)&47MCBM^AH0E10Si-=tpQR6RU-tub{ z97XTL;PcC1CL1NJrCuyACsO7qXaZmJJQ#=G$R8^5nm5CpZWe;9O)d1)+c&W=dB{Ff_o^zo_st#tft_hg@9Wy_TykW3r8yvD-5^44=z@8~SspfvCKi}oK_viA(?bsik&G7B> z=xl!8AJ7bTeU?*WOzmYgI*-|xe2UE?JciR4(6At)S8Ft89_H>3+@+}5O!09y_uC#2 zAjsMstE4fS%FVz^tWPX`G~uZpqsLvMVa71X-YTtM!`L!ISSrjq6{j94@sSG49prLV z^5P0SI0bHn0}VCd#vxjJk{M-~(fT_3OW{f%pH=q;6^EkGD%uEQxvWU3O!j5Vvz}YVkOL?Yw~ajN`OXoHlXQBeO8xr5KPip95Dw>(hyj3cs+v_ zp?hB^PR9@s1-ODf3PtvsRv=CxDTln(Qp@1I!%7i!KwsAF?NN!buwdxT6NlOCX@IBQ zKmr?#Ws)WQHGq-f>NHhc9FwFXWV|W~JbEFsz{;ZW69vq(x50xK-dn~ zq$j&%%m-vb&>RBMC^dj-!Zg_?5H5iiFa&~zY9jucO)VK(QHI%&;<}nN&^53f4IImR zOv=I}jCxEf1`XC@UkeJxgJ1h{Mh;Q(tSN<%7Q>q$QV5-doOA74IM>U)H$VPhaK^gN zx8OLv#hXFrYL9)sh567LOP2ViD&u()q1@`^vo60H$Te^z93VPguCRB>eCX zT%fC#7g@NDg4Gtae^FU`-gazq@XTbxy){r@lO|{2RIljua2U^V0VRV^?bMX@Xv(`Y zgAqxF3=V3|Z~?R(Bmn7Ico~O7Shb0|658S=m*WSt;y7%~V*8{M9ct+T7(UXu|Kf1( zcpr958OGEcZZ4NP7xY9JwLcG{jC0S5Hs!=4(agd#j}pY! zXwhD&R-Pk_Sqn1pf9a#sEWzME#!kQye8zgdAzS47jvUj@w{OHv)+QL7{rhN8d zu=ncOi^BoY{vV*dYi!kjPylBf4-O#e=)f6>Pe}sox|MjP8#%xPnscVq;R1zKkV%=X z(!L2fFM}S9Brr7S7D_QsSQ^u>b*RV}C9F*%Cd43lM5Y#;6gLJnlM2s)`PRDbGmJj~ z94-BlZ0gPykH@w359j|QIr6v#iQ5oyun2BBR~=el7(Wg1n7LeDL`Ao2&mrPkTP&x5 z++7zL8Gz{RDC)kaqrQ@GVRNQNU|%!*m+T}p(xU} zLWwRMagkNo`SgFZ?^lY-~8hyD3y+^t<<2pWsKwM+b)|`-iXg5BVVt%=As?!^cm! zt$@Mwp#6xPG!$eb>1?*TTkWmwEm%UD?bf56N8Ozrs2DlH+1}aO+`?^Qv(wt%e9+l^ zxD6?t*24!o?N0k4!RWTP+THC(1ghQIdh~F6v$I9pqRn_#rJA9TCh-5-CDjSIWD zB#hgq=@D{Y5_ies80)3O>Cdcq+QyDU9Xka?;gmHti|I6Ia2&dKRg;<`i7u0*1StPB z<>W9*2n(A=1vK#yb~alRk|EK>JtDh(<**3mT^IMYIvNy53)k@|Sq5mM0#sYi4NBRj z`)?vu$FP#9fv8Ow!hk#>!f|wkipq?L*KZCy#uO&eWucvV!4@yaMU@^c5Y7hR@R#iA zABmHXD}}vpx3(T`?}W_`$U0lCt!}$RzqerwKP2DEkqN9G08y*}pSIV^%M|AzXUqPlE{M-&s{NMU+90Y**PD9QZ-h<>VZ zlOuUp70F_u9C989vW;3YEmJ*iX(P{vKQQJ>W$I^yd6WXUwB%#uPy*jL4LDM5Ds(vcnu~2Hp<}TSS~?xd6d))vOdsj*%-HEJ?4Gr&d|T z>~!^|^|;N}Q>D@p{1m2|s4L(q2iuc~WYs2THnieK!|rM{2#hyJS}vpjm^)1hAVxHf zAUZmX^@<%v(h=tIf$<3bN4krlA9u=4#Ip2CBR~{-+}$*qr(-lvSLJg+{ia}8ZQh}z zEm&D}hVPcg9Kofjyh(Jt&Pu#aC0=(WURS{rD}`7K46M3ks?}vnsO=zk4x~p>6d)za zmhF(HVx5P>u#T+_ts6GCWd}-zM&ao+AjnEDVtNjUm@jD~SZ`}&%Z^E%KK$%LYxSK*13uZj2DG|QC`J^T)yY(}s(p#B5&Sw` zskInvPC_$~2MZ474%u;5A&ww`WgdCz*fY-IpBwwnw=dsRoV+p9t);U!VY!t`j$LQ; ze004STz(nV1Y?KDlhYAyVCjw7)f1Z8TlF#vK^7EbQ3j!fJ&#e^5JlqPlLyJ%xU7at zxBG05@#Ok$*bPQE!Zx(+j8buOw=J>|Rm7bIDMg=b@91Q6UcG%e*ne^K<_#W?y?L?s z>hQ$*#cBUYj~-{}9I3zR%83s_;T(HuvFTqz=zXh-`2A$yVmI2%1*VGuJ`t> z-TgQ8_xE=A52fa*3wiu+>ilI@Q`3$$#~dx(B#X>Mc4K6@{T}L&ce@P!k4$k&;w^pr z3-9B9^Gvx&)0k394!etN9{%^5Ad^B+l9^@`ZWCR!kEI?}c;J{?WdRc$KPL~^X;1+fAk7<7xu;F zpan#~J-n6bPwP-kdxz{nx5UxPznyHQ)J>&S^SYGXl3s}+G*oM-LYic7B*G->zIYKJ zBKvFH&a%@KTGqkA9Z)OH@6=?dhlrT zN151lc3Rzso1KT-o9zdk2amQN?kK4PdZ zo9#yrAMU{KgGcQLcEB#GuWmo;Y;Qf<0`ShmM?jeXJ$!R=^y2j^Jeb(Qc1^Hh`Q4R( zl9ySiO~;Nk0(KllhJxrChVf+*70`3I=|&xHipUQh_3T`BlgW=GwR=3&47_pJhUL0` z-FMg(qXA71#x1}i@6B8DHW0Qd5ZE_v=?DtXpj*H0$_%E#^`=SRm0BP<(;$DYTCiWf zYEflhRP>d(1Xm#}h2hGK=xQquM>gsI$T)_Ks4fo8E(?;8o>$kIU(rRLDfBDQs07&Q zwjMov^w4wg#Qnj;R(EsLbB6G}wfSKCVQYJ98;^lhtdZEp&Y@xpj~xmG-UU$?b#h## zrYX=d0)Z3;vT_H>lwygJb)L{m1$wQ_ru_4xXU_+3aD1PDFvIVwW-yP*BSSRl@q#HV zmm7+!GGEb#VY1~~S*S|X`~1ZvRixfzyXPyZerA-mp<}sJ2Uoa(@tNfXo?b2cJey-p5l-ZzsTk_{afLV@Yv?1I(Gq-FscxYyccy^z zqprvyts#k_KEg}$h-x7@)Si&0wxAqh)OdQGEsX@1ofdMH3&uVoYPaw7?<%=eU|pcd zlF1D@sVtfYd5Kr!ax#)ccFIZtr+7#SfBC^Vo#0avM3ylnC*$m^i(g~_5{yn6V<9jW z0%IXDx@C;70^_T|_^QrVLgMmAGX6B%UtFn&ww=~&G@mnP6U+0dhAiurt`q(_Cmr$j zO6v!j0Xr=KD$#TeX>BA7f2caSvF_nx4*5C+-#r9`v#|9G@t`G|^vZ)CqL*?JnP?}R zbB{0)P2J^1Fue%rHI~Y%HHmtazKsefa#k*9^lUHNC6$-UM{S#$&%5Vp>oL6sXbbvq z0uK(hTie@P4>pko0^S5MIrAkZRHM;=ZB{qH6#I#D|wvMQnJ;95%fQ# zB8EE5&+@*3Dm4#IKfVF!_wAFz!P|FI<(63Yem9s#$;)W=BD{j!wpwjl`e_ssl|QGm zg8)La@@atg)jH2t55HmYk%!_wU5gYz<%AhBa>RsVTWJ*=X3;Nt#8BdmtgxgDrNnW5HMmj1Ixrq8LkuyxprH=l>OF>|+$qhkM0e1Vef1uFe#IXwsa5ba>hQc!?|8Nr@HW#j?^rW$s>q%e z{Aw#;QC&cHodRy5|7&&jo402FmzrnmZq%>QIMw~QemlsaMxR-sc+E93m20+(D2~u7 z8z`>o+ddp*-&k0Jdr^DqK{&H=IIMW!Y&9{)93sQ zdkA+t9FE=Fad43&8m#WnXQbsNfWea@w_0?SqE*KA1z=z9eHgqvdP8pgMP*!3Ox@>z zr-vU7Uku(K9h^QFnVPB357FpdpPozOf+jA2@!sI@!>OXpVwE=vn$*2XR?ucK|+r)BsKkn*q$-=XVa8GZ}kx61Ha_T0B| z-`(CW!*63Jm*IC%i@Q?>-=We0+pY75MyDyv2d=ZGJU>$RrP0jLPm*xI_)06V5l!K1 zN^>@~oa-`;w2^FIsY!?; z`U+0h)rn?eJ=)?E{Fdd2Mic$`+Xp$@zL~Q_L6Iv7Y$QyU*;liBDqmt_=6WJsq1Z!j zkt~m5P`}DtZ+W$p8mY?^>1JB4Z&#Kir;eDprzlM-T_TI`+^KjeDj20r>6<%RB+b~P zB)Xoaw<+~Mezm;75iexa2Qw?)$0(@sk&O0eX4P>&J0iK5@+Su76C-l0QKD{xA8?TK z$qRbS;qedhZkZ=^ctXcW=<eLzZs*m|Xo#MlnM<*vo?+yvIWK9gGQJ$lN1a>{C3c)OiQgkRoOnsE)dvLh_ z`rvTz4m$faO7W*}k7Ys7`(_FG@v|rNs5{IKU!Oj$88j#l*?%a~B8Yj($H6EEhdU3tj~?#) zZ}z^mtBo9K_;co0c=GO(V?*Qk!qtu^$6yoK`Y8PQrhGt8^`? z)onvyCNrCTo(XPUN~Kb%R4PeT>a7(%am!`%xwTAoS?rAR_)un@}a=DLg~W-J>^|d^Vq1clYO`H?(+-Szp!6fY18d!{fcm(cy`9YJ>4G@NI7 z*KF$8H_gOz8^=YmgTv$f@?JRaXy@?Yjg_`n-ruYq*VquM`$>j84^IX|*c(?345?Wp zR8d``!i3I8158MGNWyg^*P$PgHZ#dHtM_w|&md3ZUdyz(#Fe<*H?Ogp5?(G7XTcCe z^qi|YFZ|c6>#nv#y?nIAJ+vcz$T}|u-?hN=-o!5PMs0I#chsJ_x*N=OX)@RL;Tzam zZTH)iU;xtGx&%$`YEE4B1jCD4A`*(O)O1vmTkgX*_3FE$oIa!Kx0Q!Sey>2hb#Eb9 z?)q)P{LpyQ-&8>egQgEZApHR2bMgZ4*9O8VNcT-?{(zpX$#yz}BV3Q@Cdu};MzozlYCIK zI~uv_9{5+Esz&wAe2P!34Wx^n zXhwR%BEmM8Xx)&vN}?P`fw~DpZjyVrHNDTx^5a0$y}=qzi5t|6@%N(m%|LTEx_b0r z%XeiC+#a4+MvNLGqRR#)GaTOa+5leM-r5&V{*<@B;xEeYpK+6`l(3&Ykdh(&vJ_G| ziyyr@8ZM007Oj7JNfwtlZOrs7PI_NVx`VKr!Hb#95%zJl&UwpmQO&$=%FoP&j&9yM zlMWa4vmST;fzxA?<*qR*drNw+3_*z+B)p~xI=_A2)${}DntwC=OA<D?>kT&Sbw zKcCEOX3|>n%C6;-(sc3(8x#U)!MaZ9=09%R5d*tx-qMY_il`g;=Z)(OKdKKVv3^n^ zrVri^3(X~3%o+?^i#E8gzKa?0a?(><7CJIn{vH&xz!I^txf~c88KLN zc4;j)&0Gemuc?>#qQAb#Su_krlP)TXHe5V$!ewTCeKnU`W7CM0Tnrb@vZDN)8rG$3 zc6Ak97ENO-<=mCN#8%3?E8WIcS~e;z=Qc9SdFEMr7K$tGiqn~BuCj`3tzFJ%b9iO! z3;PfKbmx}W*3iNl3t=r9=lG`A#jvR=$pm*JzQpjJ(mS{uin{L%y49XyQmS1!90+Pg zb~_9tp8vkrC>j>_j@e@DW;BMhw;BZPF%4KB-RIEkC;c-}bBGCd`|65uMZ5|xk3lz@ z@QBa$1#F?6@`9o3*^SA#-)co>H-m;ht=_5!FnS>tHMae37XYZh0qj~JJASa*wIDI& zH>=%?n|O#@yW9$3H?<(W>S!fExy4$x+69a($i!!!e1>JhHwb((=#S%w3!kv)j5@tA z=>|~g>SE|eWc$5#S5!4laj3dYq1)h$`r@G#du&|UJ?4vvcxNoMQ8icmu6k4yevo9o zSGpt0c&L8UN)Yd=N%Q!?oM}3YQ_a%5y;h%4b0&0V0k`zsuGS)+b+y(;FMx~MN}Uts zn&jSnsH{N`US2%W((m`FzhTzxqr=^Unv3p7{SJ8!_RNU#5hA!Xxkw7m9&1DhuV&#wX?jnH9C`jUFXXB0Jg zgdk&aM?=1Vj*_sJXd{rC&O{tMih^b*0ZTObYbnxEmSVJ%qeCa3p`@C{X3;Z!CgVLb zI@t|{>dZgkDA62gdb-_zz8OaVW{)iY zi6Pi6zsnxl(kqv0+8$T8YW4DQwd|U^$3VvNFz~JUt0t#=Hlsu8w`kfkQg#9aV$DTj zW*ax^*4ZaUjoM5pihpjjLlb z!K}I(JfRwGRZ`b;G)3RU)BOjzPkie>E0iSN-Q0`b78xXpdy)BA_hZz3jeURMxFtew zVTbOC7+b{9eQfp&m;e^nr^5FNLeFR{nL?h;5E>pwP;g$a`|g|hbCBG9S7=E$+#?5w z&y3P!S!A53Gd+c%#)!O1NV%ZJj5Y=Qm?KW%nt_AV;63t)Q#T9;yC;XWd2JNaA%PfKqc;_|qh9&;SnTGmVxeoFpr% zY)=D`>vwc*#)q`7B#Q80&i)nA=yWIbLvuQTbi7DCvi4+ELqXfLSxK=+1b=AHe0QN^ z(S4Ad?^mh?&F?{mBc_8lws=`h>p;8WT_Rb3rluZ@)Omn24kf2x# ziO5+MC%&VDdi}6M{Bij7FB0V%`TGiVUGt-N0TS`(aysfX*o()93U#8z0?qv{vXZ_a z$R+3PRC@K`j!c*r{$9U##Qp!Pca!X8k1R5cDuQt3DH> zZk_IxkBK2y2H+KYLwzOG&e5hXDiuQIl~v5qEO)BP?+`w7fia_68zuM)#uF>))ZyI2 z+4Al|t$J{>TYGP{Zg<>`fhuKUL6aFKzJW(bAZ~ADqzNpdeGxCmF&nJgyU_zDJkP`o zl@&rM0!=@!{#4orCJhNmPTH0ue2%0u~B1o#8TdF*h9wtvWigQ^gs>BbJiL zB4l}pA8GeWF{^cB&2Y6I>2Dh!#8;2GH(aug19uNc@@9hkaC+gUfjsq$*Rip1UD97g zcOf3T%uFzOleA+o3vJ8f5|YE&W7kOFi;0^@Nptnu&hFNK99&Ak>yTfiMADVM@85Q= zCKwRMnG1R~U8WuEVEAt3srn4ElrjJ=d$VLe-3%mnqOK6?gX-c<< zq%pP3JChYoIbucL_qofwG5XV1sr>XD)!$GWb8qWP4c8{ljdbQwzw28bDkwJC`7-^c z>K%JILfXNbiAGNrs8yX`GqqXrn~t1gZrhI)N1fr8-|42g`U zHK->ivu%aCexyS#2GFuEOD@=kx@REiSncSM3cs1Cv$}&zzb4ftuJ}1NFDaqUS_O== z8e{#_IS71w(UW(!N!QTrA2w3Q#*PADl2xH0(XA5yg5W#>tUd#<@bWXy3)z zrM^>CAvfK)?9_Q`l?Dv?n=B zvjLg|s!`5{NDB)0;Pr98zMTmPRLNstmk(OpLJ@{h|lDeXS zu*@9$#|p;FYp6i+E#(piU5Vqebu0Zaazt)dsDJdc`kOcJ>L*v7@#R*3I1IYzWju6E zobiLJ-v@in)H7;gXMvWvWM^=gBp0@|Yho?uL1_IP^MfwVv2#3BE2}I4lj>bj{cO(a zd!jmVXe_S$x6!9@yX&dAG=xSKq|rTSvNLDzn?bLCrE+CWG<8BHX%CSef+L*wL&=vC z00T#Zme?~sX2|PGo$55)U9EY}76j)y#d5|yHKko$3r&h};NuR_!H#niz3+WC`Nr%-yiYu#-^BtJuP-x!kOOaqVj&gMN7uxV@nZ2IC3g&ovCS3?6iyYB zzYR|Q)A*NMATs&ay`Qld*tNZJvM=2(&1Twr^Xx-d_5mFG0ET@Czs||7k$bppxqsg# zNBiN8m^;(uODnEHcdqVb4?sc}t6C`2_bnWRE=Xp8RN*uD)!IO^r-$wvglNwP2D{73Bc#glhLq1tQ* z+#Va<{&hCAF6L}M6I|dz!Rs6m%u^W%>y{+?Y;@LFmh&6yD{On3NiT1#u4GrZC#6hw zc_o)w?p8%kX8FW`X8_0v9S}d>M@W`l!=m zKNxS_st0nfp+Z4C#}N+{_;@qI3S$A<4?GOgy2gy)ONnbe0OC5kBm$m68SR;LM`yZ> z|L!rXSi+HK$12?IUE77wyt9Q~oP^H{t%h7@+2aqLjket-BPF9BQn4)u&CAD?X0qOX z7eJT-E%*A}q`V+@6b1cYc7WhtoKcY(@LQ2Flym8YQOU`h|7!s}1$iWF)#WyIplCnX%^yuxsY#7-Ji zgy~9s>(U=~J3%u1a4E`e7_*-d=MTN>vM9uTm-ylUK|XaKXi2qqUncbqiMdLe6` zZ4nclOsc?S@(C$dOqTSmYpJN%fl}FV`6KOwtrMh>CTN}I>*eU5v<>BowqkAj8idxm zsYb7cKeU^WBTnvZz%W_VUm}jpOOZogp8f}$BJiY)8FTHF;x>`!)R?-`wtu3vmm)BLf<#gUEwvpagF|Ej9lZ6Bi<+tpf!f zk2RCd@xRr^`2b?b?nrPito{XwM#|C1G9=K%j_|Sgmm3n`*uPMsx7xez4EsG6u;x3a zYWPw_SmtW$;jD2b{UVHG4XFLvRWhV;BN&5iUNDN$d%Zk$YMsSVvl@Hn(&%3eCgWfq z^oY)=fk*hmPOnWa>HS62BKA8k^xB5pvWR<-%^$dML^|lU<%D<8$hpFviwrh0+y)dw zoWGiX9^Nr-czO`$MVe;0X?JKp77+cj#wu);C4TL5?A+tY+B51PrDS2O4$$PX zS+bE1xeOvjj%+VN+}|bhP-T!c9qn%@R5Z>Lk+ZOJQbcf&7nRM@mV>gHhgr{D)+~P9 zXWCRsy620eYfIFLl36Qj)>?|HWi^(IuC^FcEgy}eT}>OHrQv;sI1~|Hv*rb1<{FBJ zan@yW;W9a0Mwt_3tV-!RCJE4)lXwq*;LARp1OLN2Tps&j~(%BOgZsXPy!@dlW1>4HLM!7|QzHX70Rgh&#Hm@rH?c0;&9 z6K?FDMcq&Zjx_)+I4=X;_rZLqJNmjr{6%Hgbyw$$Z(-Z|{+Im3q!slr#XLv7x90(N zF#ElTM!P+DG6ymaIr3xsA9xJu@l@UiY$8jRiKKEAjiafruekjahlh<$gpiHCQomRV zlLfaswv8qd`%tf47Zg4Bl|(P@`r*AKA?=UBf6m8$mZ{ht*61$9$i49PAD#Y`T*tO_ zhZ$L@!91aJ&y_*bSjmhI8s^V9%fK9_rF#%!hJP1xa1HCxd>6*(ofC_wUWkCyb`fPH zdaAxX08zp)EX1|J3LzF+w4oHuXJd5ZXlc>PMT+uHVzrls{@F=w)THgi3uS_LN`Jb( z6W+A@G9Lh&XbX{Zp*YWSB*_#9W~TESDVoFOl$D1T4_SWh>oO;S8%ub1dWP;MK}KQ`RU)FwfUgWV79U7E%gEC{Nm|dRZ2+hT8Jqy@p3u zZkQ=ET`Q3B?nIwq*MGVWw?HiS$FWT z^4jkjYa#ch<90A1u9$Ybcv5(gcA8=oK6pN8JwS|IFBz6%C=HWGq(Os6>Pk9ed;q0h zywKNHlsrSrl{1`%D+2S$PPuaUmd6qXXjVHSTNunWP#$KCfR=H`vG>U)QWNA=x`G(`NzILV9j`;=0Qak1x`Q`M&>J5OpzrvJN_s#6L%^T$i5~BGQ(dy zR$DCUFON|hTV&fGGLbGkVky5|YDOeY8)29oW~!SrEkRyr`^}}DYaRf8G*Us*6<8&1 zaytT&$m;}{V0j;uk)) zsvDK1C{z~bqzv)j2TeFze&s@&)qZAjG^%4KMhasA78L!ZJL`ryHaDjLdlB1BCc2;q z)Gqy=@Iq;|g;5QehHFJBR=(KP^h;Ro1$9dw+#Npmtj3@R0%&+;C|MI2#J^+t(87TE z;4HW;>3TFKJybwl*nQ{v7{RrcoS^gg2^L4WE@B(@vS_tyuZr$$vM9O>@HNq$r`43;W)3bqk}|+5_SX+ zc1dJAdiXN}pE)*-h|a8|9ouBJ&yxiISrOg1J{iqC(cD7-8H^LgJSH$(IKmqfOpc!5 z=td52*xjRZn3dICj&uAFhYt#E%cXF7SLRXFX0aAAP%^r4Pm^rd*%f+dEx2XoIeKGD zWPxCm+Un^wx%MIR4Td$~2?z43AoWvj4ptbJ#X|!eAj%^{7$;ZkuKDkkkaIJ)Cxa+&l5(FJM(DfHh&pa|9-|*W zr0q!IJ>&3O&Z^`2W>q*fY21nUvzDKG$R0;>lHBhw=7i_E#_{L&>7%!04+WE9hi@v? zquS2q={9z%-K}qfbgl#gcER|1cXSjC@f=_bs;N9B0nL;b<2&>(pv`sr?OZZ(t?S~g zPDo@Qo0Hb|7JpKyu{oLp8yQkmxKNYCD`|^g^RhG2>>E#vcLrUL0^r zV}4Kw6qS6yEHgIcd24v6N0NDz#bjbI?EjZ5+cNGV9rsfc6B!$HS%jT!R?Mg+WYxN2 z3zlB11e8j3>#$O-pY2wvhxJVa?HFBP;!;m zo!fPEE*w_(3az`c%7KgX_)_!jo0(ePJK8C;EXT^p&O1)z8c6()oL<{5m05Zc{;1fQ zFdeuS!Ui5RGhyxW#O((&dCHG#Q|a4joLg+xdz*arc=B804xiehuO@`FZ^2;Cv-c&S zbX(JP+eKG{NF=IQj+04H=>fx`Mw#7yCzPE@pjh^BQzTqPl0kR>5W3Grf*m)bq*IK8 z^8IS9yr(><^PB#t>g~(Y)@+o?T#wu*pJIO64fByB0MXgE#COx0IR-Kg8jDdw{{QS)b|gMk9Op_{Z)TBxUBg@R6BaD?gWp6VVl6p)XK+is=y*!ho=WMwjT}E z+4M(&s+SO*+78Bz%cLmAsRXMof8Uw$a02c2xOd^*3Ui_(q8&K*LSamd?T{P)4!#YU zjZ6n0ImaNR137TqX_iCK86}*ZSqOLj~w`w1@};*S?5=Ii9+DW z^~`;&z~tOnFa%=lR)8{Ig1g#@hE`N3L1Cnx1|6}(nuU^#6f6gA$C^h-1vV0MmxQxtlh{=T?W*#;S(8)UG{b?s=7a?b+Q%}6$O~76rQ~D%cy>_&_%4qtyyC!F*P~EQHx&}#v-Ta zZlJ^U9OxowF?PQVC!k?TYBb?VpiFccJoqM#2ggz~2%3N86r^ax&cMulXW(0Z>pfG9+kJM z4%Jf!?NU`-3aTxCx%q7_*zRYN|K)Ap$*P=v~e4pbF4jxVntc_P~79@Hn4Zn*^q6=%3Gz+{z zH>#Vb`$s|)sQLpw-W-wg@FIqXn>)?hX}xvROv21Cmo#G5de6C}7hb}Q*yYMygLCGZ zWyKsThBDM#4I8*W{}^ceHxi8l*9dA|B)qm-s7dh^1we^6hOd@tu66%f+N-rt#Ml4) zH#!>#ckGV{Vc@b+D2^xkJ5%2co(@a;2nl0YnCMhB&Iy#jOe87ku;sf0JRWj(zeH(n3j`o_x+I{ZCY5GDDwNe$FcG&s89o7>zZE z$#r@(Hu7|BGcTV&8K!U}&4KtBXy>$_v&^5X&d-?n2Of4o=VN#^0b>DCWBw^bB}~Zj ztqXUuXqTPZWl4ysW-ylSC)q=kng?yAJpQri0Wc#%!w5N$nSxoxlJa59UC9~#i?IaV z9SLu?hyy}F*y`tjwIBMAIce<3AdS#-obZCI1?|5gfYG^Vg53|TMU9YF5~->T@xDv&W?4x+@DyRUH#n!!0^+N5zeH6ebt z%(_Nd% z^%do#aMDBAc;43M4TQW8v@Z<6+_NpDvNzM=%4gO##EGA9jI@VId{c&y zD5sfJz)6BH&)Y3)?+Re_`o2H2sD!A{{w~d;G`=R*>HAbbB1%FCzIyC(}_t$8dkt`t*^$ zJshN9$caIZy$H1fyZS=|Lmo}*4?qNq3y1dX=Mpcg(dpZG)cRtiIVL1lBC*#ETnN9SjasAwFHK-cyWsA!Tjj; zv~GNKT-`t2tL+}`?N%%NBwtfROcNlTc@+#KtBSI5MyEwNn;$rc&JI^8jgqZPYhdGAUUrPt)TEn{yz zYo|VRZqOSXi2bf~>+tZnBK=$`gf%RV+LWxe1BD-ko-;fTVch9KnH=C2$BqqO#d5|OpdbBuwT>8WQFPZl|LA`GEi61MtR z1AiDKsVqV@Y^2UoWFV*pFR5N*azA6^V33qqo@=*A79R(g(Wy zT74sE=~IUWDl<-|eyE zAPhhT|FhbkG7ZQ`NKuCFx5l{E*Fgil@Gm-Dm}sb40t;?9eQF6a|n_(AmR83|M3auTY@YF6mjVXMK=g*7tLbeOX zLdLTL#QY`hgA6b%XX?ng&9gdLM;(?kr8$ZTS&)Zkjx|Y750gRB(!mH1=y?p2lxK~1 zDzW%rsBC6GI#eLblR(XRY($=d0=dV=HUA_~Ga{_?qto@VpguYgpP;+hry?Rw{ik5g z{F5+e{t1{9#okj;Ap0Z&$^{i+rj$eLmx=6})O)Neli`K4esZ{7`_9!@uC|c$>5ri%a*-KCsZ}!Pn?!9*5CgK631WoIa`JTy1 z013wV9zco?Q6QM*bY6s(qPxbzI6ZqdHz;9~oe8gnJEsTZ>LlL7QH=%nU`*LCFFgvX z43xk(9@pu^a78LS4yp+0A(-Bu31abmmUsXk%!0^RLH6MO2+t%dBX{Z0c(4)@bBC|DwgF22St!*jbhah9wmUtMp#bYctn4UG^gxf~IV^ z5jB@W2)|O6v3Y7>*QGJdv;K3rduH&-ra-&`T@?w0Az61<8Pb93eUZ@hfRwG@V{<3@_c`RApSKl@V3 z&wC|d7B#MvXy*KRtK?6=RU!rAL47c@>QV6xI7!F|fMxaPCTI4Dx0=(;Q`@^nw z%OD=5D*t+FB0HXu^JwSN38jk0qoKO)`bPG9w)B0F&+8B{)AO|hTd03yd@qVS&|!Kl z#6|^3+x#nC83DJ(Im|CbFD;n8;3n~W?zZQUAP*w51Ki^h+8snJj>OKuTQVHkBa=1y z9xYXMzAqG%0A&V*noU(5*eOop+&hqst7&#IMr~@%@pFc`NxLMx(mS1TVoG5hF>dr` z1{nD0HPw}JbpvVNAAL$P3OlVH4^kfIREdh;8HmL>`{szpVuv#kU0x_zp-LVasAN`% zlG(vYV#AU=EFeh?cg(GLM(TCN@1F3kp>&3Td(hy;28D_Y2Ne?t${hmge!-vaGa?U( z*;)MVD4otxi3rwtuW`9gB+KX+mT}Q5BjQ%xJ7Q&Qtjd@um2(ZQ_$#kZizrohAHA0O zl;-3=y9WpSsTgi`F8V!u9`=s=Put{Q%wPKGQ>Vw=Pl_`LTKs)n@oA{|A92OMgo?k7 zD}F=YgbkwlW^Cs!I=!a!Nfec{%N2N1;1Wh^3( z&?E&Y{8>tWqW@((3Up-8jJwO!&**;>|Hq(FZ>9gmJ1!!P??JPc18Acy;c^+BjS3gb zx?*mgiriOoxN?5Z$~jl%9xkEtViU&KPNh7Kt)D%Cqk|b}(${wsFs9X{QNNFdsP%$QCg2p5@0&N;z>PpL( zfzD6HLw1yBycRt-n|Z21*82b2*>eSjlDt zO1b=cW<9I>>qA#A6jJ4_>dAJed(~;oAUi5W%;h51*zFA_Xn~MUfW=)1#ARh;ExWOoujlzSFg0q+>p6avJ-f2Hia(&2Yil@H zQ^gQQhm&yxN-#RBnPt3^vIOm9a+!7ZE0f9R)(BRRw35$aCRBjG**q_{mRnn;h_ST% z>Y4zunpt5ru(vslTQrjb^)u;J!m0*61y7M|lWWw3HLB~*>-rJXFr~eoG1~3z9#qT6 z7+Nz2q^Z{q>mubu_&MOTlrwjg^>>Ng0a{+=zcShN9HWpR5Hi8~+A0dSEO4SIp2@6Q zg@Cl{0s^oBE1q4)@l~$CD29j+K~ErTV+f?ptuc$BHo=D+} zeJf|}E$YX&C_8R*dXPYZtgw4-kc~OOY)gq{AlkA@gCtOzv+0dhmc&Y|rq@^3Sp`)B zCVy^YT>`=HY<43nvN@@9`JA5p?RRre`}Vut-Y6JTRnM6C>o7}mYuS~2KD)B9p69cA zEuUTA0NDgcEw8a87~_rgTsF4>|68$UJV-6bSq3q;o?TgI5@Kx?60#c`Fwt@=Vno+g z*ETkmv+Jvwe0C$_5F0Dm)y!%ZWXy`dBa>auL&??U)wPvX_Hbt%1{X-Nx}M)yU0>O7 zNtO0Hm{-v~26lz+W-=@5+4b!5GJq1CzKmSIwwhmtKIahuM{3TLDU2}C#nsj2d}aeC zSw6=n1grqL{8}cL%K~k4o}*-LW7!6UEWeT8$gi(u*Fe6mtmQpddTwP6+W=~90A(_( zD;p~rpuI^7u8Wl0xBH!5^_o3A%;wU|YXGJgD&pU=BFiB10mF^r+{<iTchO3K`?>7b?1;N!bK)p9`TyaFc^t<)-W|Wvo2daSP8^h zCd*}4W-}PC$|i58Cpwabu8^;`pd0$2B);<0Exp^sE4E4`UMJAi+A3aqUEoqZQP7Ao z#wqC_G}3jJ|H)uS*0}x(HO|heSgluK>ZB4T)#X)9?ml!WR6&*K1vf_=6IQN?XSa;A zSxbxXvE*otl2<}_$*O2Cf)XTiUz#)rX+buyq^hTwwoDo5s-tHrXIoX)OSI|cU@{u_ zuVPrsBu?V)qjzHN8x4oJ&z$~mao0yaixI_`n_P7wri(}qz6eJCrUm@*IOt6nbt>BD zf+IDelJvxDCt1b>(oY_<+1*z&+9A#2d-|H0!aPL5#J8(f*=;e*0NYV8|F5Qe~N9fFtg`iN09iu5V zG9DdAo8f5qX9rKGW=$Oauqv{IM`?`?aNP`y&5ZkFzbnHl3&1qZ1jSqgM*@@foN1ig zu&gwuw6HRX3@~%tQ=WK2&)<8FhYexYjGk-eI-nSC$wLw5_&t2m(h09AE}_L^CCZw9 z;F(pKaJQXh^LNn>Kw=9CPV$>fQWD>E4Vqn8e^zK+8-vBV<`S&o#&`G>*T>-JA>*k8=;AMi6#et zWn~>%m#o&MtJWo}b?L4(CAFqzttqKBr4Io!Z0{u^$WHiMHE7>sA5-=*6=qQW;*31@ zpK35!7ntn5!Q^IQlbr`lekL|Ezz9xkYhtn)h{L%cRjIvxGszik09!N8O^a+;T}868 zhpa1_O8`yS(z4Uh!$#?g_aX7zSgmWMw1?%5)et+o~OH?^5mq~MCMQ%b3tuTs0{+O z5p=o+P`W7-7<;l2<&xYUX%>cwE5dZkaO_V*5kEZJoqNbLwAMdEH!=FukF>2N(8te1 zrH-Ek(mie~nZ!8{5XE7U ziqrUt*~p4t;w$FNis4WyA$l-*qqk;eU)Aae+wAUiw?C})m3QCJ^%%0b2@jXKrmCVW zE)g>tzp2$hz(+*ojvhBTyDNyqy& zM4?*=_H-|p9|1Pe$TYiVbF8d42BG1gaOK9ro^#>7oCUeSb{-FhA?HSn0xCa0II#7Fs%f)1E#{e+gWhZi@#8o z14jXh3-N?6T^4}*%RCo{3J2!IOaP6Wxt6uS0!nQL7TAG`Lm4Sfjn-HuH8GeuxFHMW zD9@tG;1Da$ZQ&p4?00ajZM>0pVI3?Z-V4ahab@@9sCvxz{n`a)nNw) zS+PUH)9w}Sq*U}<^JYf{amveT8kWcD(P8%qNE5K&ak!_>Eung2ifG)mu*VnvEl7!qdzmLQPoLn(PLM4^^RV z>D7!$N(9QGqqDM?^7jp|5h}c>yf-*9UzU_x41;TkoE9O99qW+|&9fE+5hY!8#pXx( zz$4tEx0H^p(5XpI93*^aM&CL>QZKD~DN7U0)N zje_ia$5oa^>~U0J#{rSG*qanbEg7F9qOC($L;c9|BF48}V{>vfh^#{c#u~Lq09aSO zDzoXIRUI{}Y#v<)k#+a0wep@0_F@t~82epy!se=Ng^Dq1n}J}QG*#T;qHV7;>W_#0 z!8EeI8GzQTzD0u1&Zr$tcUJ`7`vjJafHs>lc0^ed(5?|pb|wVtxF!;od7$cc{86nQ z)VB`z4v!t6PA-Fhi{}{t;)uk6%qEa|>)eDuZ>a5@zg7Wf$LQqigTn1YER0{Xt*=PD(U$=X~C>iyI(*IPDDS*`oT(DVTclCzaLxaE5^DQBBh zk(%A^|A^XEd#KuVdaaDhc=DTNZ$YEC<@}~48ZD^m#SK{i0-cwho^i*dQGm#vUF%Z} zWJm#1aAlpDz{%ELYgO7MtrNJcGaGYZ0TAjH$GPuD_;4P8+C-rAEB?ybQpXfnQDG)v zx}PO05(6IA$`p82ZDs=@#Vo92vBsiQG}WX9XlBEvrNdCVSc5KIO*KX;&uqvtiKIT3o}s**|IFnmZ9NRidEw#j5(XMIKrXf>Zap4Aq;Oe3WnXx zbilw`btsU!JzaV3h71aav_YfI7&_a)=5O9I&bbvs0}ZE!8AgQyo{3IK%XGYxA!k7$ zeN#1W0h-;gIq4iTZ5%tjW=^S(-i=H7tR9?kPl;3kh1I@RhKXtwc#R$(XXlqn7}9kJuGg_KsF&F|RIog=b@VZGCkux3Rv; zowD)=wkx@8KDU<1F4G6L%Sbja3?j3(mfzSw&l|FA7p7(H((hG2PyDXgsHYoQ&Mb3x zBPQ4z-b2AfW@{xkT@8meoNW3TQLoXRG=sz|d^CH-UsKlc>LDukztIBhE#+tcdOyjB zG2b$|Q9im+59!dYkcM$})$jcl8dtN1JkGb?;t?Of1$>(7P6nhK$%$c4fAOcRh#F^&LKdTHVf| zDhfo+rOobSIPCCOW^>Fp^Rz&fIPQ;qK5%mnEA+lTxvmd`R+r}z7O}=UlA=+w8%diK zwDBBhD%qtegh?j07|qH~QrD#C8?QM0Fo;AvhGyHIbI>F*?Dmu0nsPc?1k4hHtWYc_L=qEa~qh^PV57hU(r1L@CMC4HO6rdJW?5aN;T#o%=I~Ye5VNMWZaOn2i z&0sLTyqL72iZozI7;!K(S}-z;nF`NNr+s+@1JuE7!XIyoVaZAQ?%-)fF-IQuwiULX6u9>8#Cn2w# zKdww>+Miuw9E`>@id_1m%jhDZY33^AoM=P~xz|)hAy^Lzukb;pT_>4kN zqaOq!T|?}TM0QG7H3ZSQjQr8rjP%ZIN_J8}sH5_A(jUwL4?c9Tsrn&vo_HBf&7P~L z%yIOw7A8)8{fKCZVgUOiK|P|+xd3OwfN?@pu$#61@te(Z(tsNaEEk2P2{LJ6s&%#~ z!1=iV+i+b9AxM$~lqACcsI=7l66+-4@4hO>FS$S0)E{?EWmYfH>+iRq#zuYNPLN?9 zY`f-x;bjGOufY(HCiGM=*I9J6tKS(~+jE-r;OX^uT%BhvymG=N9(if~3)V*Uka0|3 zVVnH76y_t=D^V-St1lVMB>ajH9tsuE5VRXtmf+aLg_bl~5T?Q5-*S5nh;O=0%hk^l z*5*BoRS~`7k8E|P$fJ3?$HEO*P9SoM;nf3y$mul+2NbczRz_=yy{93i9%p;~g^-Ix zdoTXtk6|D#CgVW**#LnUmRvmVde6v=lU&gYKf^F8v(;~ZhbHjd`)`W{Xm=ALjy)*0 zCW&V147|hlQ3{L#k<}l%UO&Mm)*L`GOFt2|qtDhOO<`to69g`Im0~-%4o@rgU>>Y=-7pO_?)?EA-)G5Y*Fzhb8JaH9RVs8qAPklX#`* zPsZ&&G$G%b5|^~aIkuK_Eb4p|NtWHDv9IQjK6Py%%;!nqhWs#5YfS}b#$Xs+O}gXG zpxX(Wb*5RE!g}Y)Y@tE#I%c!=grfP$O{e$U$32-$cI*#Z)-?ymr3raELWIv@$4ig9 z{WCYFGxmmb1IIm6|24bECta!HHkV?W%wFHl?z_IpSTNgrWgaoFTCsgp@=JK9F_xToGmAZJS(lf};!*v3to={2D*rhaYB~(0 zz%jpuAYEPz&CgQ8%(oop&-G#7Fw-v-_zVzNCj;mX{N5_X-<-PjRF1b`Ny9LutS6J-x=}Cw^1LT5JBXcT?@sNrR zdF^D1A5q79<`UtC3iyVYC-=(xo7Ll*Wzjh61UEm3k^X74N}+Q+ozBT)sK#La4^~QJ zb;}v5<$OmT&O?WpdZj)3k7)P!0nh&F9A*J@uCC34itpA}HIL6$X5TtwPP}r3d-prgS zab;rguuFvSunU0x|68p3KaVDFZ88$Gb|G$l`iE}--jT(4zg*jb&E%i2|HrECb8Zg) zN)7*~0{>Hi|MSm1=g{k6g1-+>@CTig>dOyTz$W+{=%I4re?ak$)n#XCr;njh{xkwV zwR-ko?Tb$rm@Spg(7Nwq%x9(M-dd%YDl7n`zla;SODg4-s>tZLx-slyYzUF>C2sXa zqRF)iP1EdyHhwDulc3JcQl>gZxR+nvSfMwmwND==TZAQ=%LvEaBc9>O2vNqfGqV!C zdd;57X3{)vGFE00gHqv_XimM*wgh9i5#7|^;OQw`M5 zGX5Ku645sZei-3#&->~BI0egke*Khc)`QiW$d^O>o{4yqM6?U@AsRW^K0GS_ep~59!00mKE_wZPMQ2)oai^vDu)>OXd?F{7sKkiKv;>)lzi*(R)T(sL}yLiYqb5WNF zhqX43xg4IT9WFI(C)93_z7cMvW8hJ5(i&!r$9TKz$}4;^GUr&2kULg`3`cFfp(gRB zV_mn022VR@FUI7-u*YRY@pPsQGCkZ> zjPteoU<=9Rbku3Y*)QU~96X9;WEKk4i~e73LQztBzLAV9q?X~>*3_E((_-_}ViUnU zZj348Je5&L&xP5*qRW1Vtw>0YAIn_CSWjAezSCM{u(L7%mA==6WV)K7;&qno%jn#q zg;$(m%GT?i5w)$_3x@6KR{v_ikCOytkE!CwBgmgcF>1;IGkGXsyvl(CN3dz!Nn=Q z%^+>pPa2n9(2_~#)fC#!c&^lqjHhs!i#pPyY8Vz|A|5Fq4GClwB3md&l8)U}41;yP zEdP6&BY!6w`r0Av#(vm~4?nGmKdp&Bt%*N|H4y~Icwh;RpD(ZfzMJ;;5Of?Wet(SH z2IKw@uv7lIEBznamHvs>1Q>(=ufK)yPGNm~0o14tEb~ zC-u`aJNP?>IeZo!yHQ%|ok7$r!1syl7~X&V@NSD)n4C^;%skMR1iKg}h21}@fJh&Uf48jnd^qc!7PbNfbEI_OBRL=e4n)Oo&1CIq3W0pCJ zerYO>Um`rHJ*_88OUvvH?(MJg!5)-_7BKF>KL0O$*ZVioI3C|)vZDTj)PZ|0`2PgQ z%bmgZIbQzDeI!TNP9iNH|IGInKb9}z$FdNNY}wu5Hy$2m@BfIq(YfU99J@_fWb|o< zG@dCIop0b6`LvwYc5mR06V~)TG@VQ-_pVPQpkQc+A?0_dg61?l0e{N0@!m}Mi*sOs@D1xLIwcNw(F{x<8lVM2{o<1b zJn!Tx)@)A^rOyZ1!D0LV4mvFje7LWKjwgwn(B`{7B>&Br8;C zs##$VvJCrN;Z&xW1$QT&OUo}DkaUr>4M{}PEF6k&LoqFELMp0Hg)bA&b(yd52@1IE z>V=(&7sa=Qvv8hS`AtLtfz{h^w#a!0ImXVg@Lr~vEqpeTMeYB}MDhIxexqC~{0DwT z-&HL9YvQ@|`og~wfT+=EdU{nVT=Fjpa>A1ogeEDX5?f6#@))ZyXnO9W zvci?f3Hv53v_n~D)w;^p`-;M~N;Hi7g?%&Kgmj`I84m{wQ!B%)RwcRC9kRkjIM1wH zQw7XJhQdua1J4!;<#0OagoR^BcC0dmEi>JchmK4!*cCHNr0z96QyTJbOBSj`(~ML& zurkbQ+mP$JXIMD2GR$h5kn6B16uyXbL#})hiKejF5vgH2OX1AS5~**Rp7VIB@HU*m z2JM|nH<5pDrVH?&RjL$^G9ldkKS0LBUz{xbC$0!X?_acp3IE?sFY*R*;rFIzX$XaJ z%M)gTLI6KwOlO52=2P=XVbt=%=RAcWO|@iV%X8jdE%dDnvs$<1MHmtajZl^ph%`e= zM4e_^8wyRxGi_Cc7EiK`b%g;*7fDwl$zX#vBsyMK7wTrZiN|%zb7^XYTQl9Pv=5oC zi=2fME5ocdZF%eeKC?)sZTACb)!q*noffk+My||%o$ISt061(#!O@7-tsi=8<7`# zXC$#w?|Bm8w8Cd2iIw^OpUKrgB^*? z$lTr0Szh=mKSHocMilrvq5BoS!ru@8o^~t@EH-8>*Z@?GT1!9^shnS%r0VpC>MOm% ziVc0H!yhAXnU~&J2b|c(s_@nChso8ap{WRbmJ!`cscja%%J^0$+)&gj0$N4Mii9rq zUxlyuBLrI{MvgG%pP&g&w|S?R`NCKJGXz#8M*`+04A7W$0$lB7Q_zUD^}#uy6G9DI znUT%Xa#p{Lyv>e3qD)P;RlttoBg~UJBYHrnnppU%zCyrgPBb*CKoq_X$s02X4Y5i#}E>}^?)%UAh9=QV-lIUEk zd{B@0shqVsr&qi*79U!QSLUzNIH93l=_}iN6uye1s8Qilko?dXr@00V%5<9OrTEEp zOZ>$&I{YCOG5ihd(|O9{n>}QDAjF$-+T8Yda{uTmfO)`Ve6RC(co9VeKZSOOKb2O7 zAC~qcdZd7jJf*}~9Fc*QH=^ToFBj2uy0wGZgxjvaRoB(F#GWVF?E3P077Iv6nX*Ja z6G%?X8LQ&R!TM;g(OB)oT*mopZ<3aClEE^XIq7r_<8bf@(c8%3TT%@xFm=4gi4)b5DMl{E7; zT6yxuxr${iQ4m~$D}wq*^BQivoOWeWdn0txipN;?qoRZSdurk6C^jnv=-M* zW#NwPsxo-rF$*{Cqm}wrhibmQ=y|4>CSAUKp?SjrCvF20maF4V?j$YlVp+?QT$kt3xeA+~x zH?nLme5za~6H$(P;FIN+qsv93O$$Zh&s?k!l4w^huAK*U$7h|D(5(2@jveZE$UUC} z`dp(=4^>IGXmSX;l{pve6YkTGs$HDtoyEdU%CVt1Mh@zDo{{v&uu@Lga%hXyjFB5T zy3{$Ry}9)GRJI*>x)01|^MUQRld^)tr>DCaS|XY(mdi$av<#PwmZgVgMVhZ3Z7*1C z^n0Um!XK8t4htFY0{&~`(EZ*kVO#q>SdiGSUQldJddx_!fGUMU@Wr4H> zUIop2OBV>~`HL4bs%4;>m+Ykd$+*wbzkQpg0AXE??SZfwS`3qbzvswfFJa6))tt)f zaF0&3HAWwgBvcS0O*nxm)aZ0mDLo8V$*MP%e1!C$0{sDJMsUzf#UOwCR!NIXFF=-~ zVd{1A5`M5N;~6M^$vE&LNaCN`NQe-RO`9P3wdY?2h3A`w#=S3GQ$6>Ta`byA3A&M~ zm@5s*nt9=ZG~1qo;nHRSZv-o8;a$LY!OWifYnFe!W&1$*!b8SivvMN`SBcM7SZ7@gI zzy^brR&ifPT7lhjW0 z!f7V{?(R|^WDT0=SM3rA@OzKplANZ)+cTDXyHHxn;*Y8P@rC`c*oseV-u)W8EGRNi z0%d`(LJ*K_%Bh(X*;2(>L~l)HvHPI%dMOK{)CJci_CyO)XXXqjYMpZcQF$|9$f4jM zP;P7w`&aysY&qE5mz~x)c}b=n=?W9hxTK`iYNA)K1{GutD#&g|$()yq z7GraWu(`z7{G!V#w%+&V6I+dW#Fkr(G>90vnp=j9a}|dGX)sj6{Hsa>4>TTOjx-*~ z$rT}3%dl(;&P06(*@pK(yiIiXf|&2b^kb4z0!`g(qBI^pQ5x|Rr9rrX^n*+kts}I! zj!;FyVE{{i=os?5U;R=yIOoM(38X5j`;Y~p^((r1)FPFbk?SU{RZ0P$VP}!&; zQi;$lTCd@%*KpOlT&(_&XZ8fs4Y66 zb~RM12FA4-U46&z~smuf|vpd zfNr>7epf%M9@nbx>g8JPcz5#z#;k-_9ZG{F8)mj&7?wt!k7~Gr+)wU%W$&%`$@|Q; z^xw6X{;t$aeuBJmsyKwvcn1S9EWPs@$zi(Bga;}Jr3pa5QlH`D#f!H7`ur=`?q9qZ zONsCql+@~8b-#L0tCx?D%kS%(r`y}rW0)+zfBWX+OhEL!sl7*|@u)Z=rOuFHC zY|bY?rv$rF=I-iY0-bso06u3-8kdJdf0`sE8_9iA6dR=l_esf1qa>HLQDvLFPjV1H zmENXrI_$#d6_-0~gg%#gANJFo=6UfmU9CRjSc;s|XFiy}mp*?ev!cJ#qQ7HNkyHAe z7kyXy{llkoxvhIgi@yT~>EeXL5~X)3@0~_@fZgNhmP;Sby|?(!C-|obQZLET%@jYs z3W}c>7gOaApU+|6`Ii6r#Qqf3bmY^wz_+KvejB>YKNJyg4TA+(tyQB!+2b;;Nz&e; z(Sv_fI@hq3AC3y2JkF1WeVxf}Bf-!Gx5ALFdNonZCHnTcG)(Jyz|v*%Dd?9Gb7DM( zaRVOH7{R6!sll^%5*=6@$Ei*$IUax5IZt={4W@kkR?5ic+G7~FopT1bI);&f-%uWY zl404wO{sje!`C6$m%{iPNl*}~*{LbdsLkY?QCV)Vjk+um_@J%v`1Y+m)}(-mSRH@+ zRvp7E2fe```z(e1O7U?9CVscLC}ePgQuSbRg(BqJw_%zM3VeLJBesdqkih6Y-9R9y zwjh1`VRUbQ2i@Bax{GeXkbJ!>Rtecl?JZznuMM<^&o_Q;r}CC9+$XcG8(6_Guyf|DS$BU^d^DSxyGgKvCv+; z_xO7}9RyyFCr^RYN5Qb#WyiE$eO!89!rjE~LG9Z&{`2(UWcSTMwNhtkfJJ*SsR0Pc zyzO&J!loEEPeV{suLGe_sUeen>as4NeDSu%rS3RA8sj09x5v`^trjS{2(HV)aT+y4 za6uS|8F4lS*?l&Cr3V^m11T^q=sS8mt{SFE z&)^kTwgdh`7f-_>Gj$hqM?qp9w69FGVQftm)lf~}jZ?*WfL1M9RL3vPV%~dL4`5Ih zfCG|yH|6b;ojict2o(-npd8J1PF!MCgoeI^)JAB#FfZ%KHE#XG!^7 z>zW`5*rbXVu~>3nSIWvldZRB5pQSjDrU;&<@B8r^eMV5QwPG`M|SDSCSU z0lS}blKmF5%X&A3t0l?)jM<-3mr2}*$nC1fcW4PrD~jJ(?@s*2CdfwN26Y)AzT9`I z5#ai5kzmHQVNZ@6wxZG7Vycz`S~lqQ7O*Na)_H4VZ>>165e?x#H-e%nAsP(g*Aq|& zd^BF6*G%uOnsM;is3QwAdiZPrXn6H7gA~u>4F0g}yfo;8$Un|E+NL zJ3&uYg%f2;sX#6)N~3^fj1F6Gdh3e@*tHiK3;^lz9NI7;^LSU2Sb>QKh(;gP+n<0sj% zZ|W-=8@W2HYb!y_!9Xz+P?L^CUqS+&X`*f|*_^8`&)-%z-|W?yzk)h8@jR7g9~IRc zE5Vw|0Hh4SVtcj;h*2q1+wi;ns#$D<44o{NE zKM}{vDYNy4RLT(vpdaAiAtK%Y{z(cm}4sEotqxJKJ z0sNzT+vdH!W0rJ0@$EMQm?rF#n+Hon`Xw$B0A0?kx-_`14ey&n)b-JMQ)z!6%PUCrs?MtL6+LEI*t5$Jj8#cF? zVY3DmPmim0{H>#L)*)4>0V8E-N{r~#*pkM%Uz1zVpJoqF_5mqen;?@J;w?k!?*0+C zD>4s;JdSDoxLU5%w=tk;&73h?vX8r^Ej%vo;od}(h&xx|%6$FO@3!j9Pu=s>w{KCU zM1fS1BEI)sh}Yg9RZ}lsAfQ_S^y{uM#kSaRBlgcPJMGKCbN0=^^P{JuVbJK{(Ze?G zZ^n=%49zDyqf3wZmg5UX3VTK7PM@@J5%Ly2~l13jwZ_+P`JI8+Wyn zG75(iDOA38MvPH%1sKpa-Zi={t4nc(p-56JU+8*5YIEj42ChN1r{K$Uv@fXCzNZ zJV3;#P{prpaoVoROvNd_YPy2O_{Gmr;f5%9O;}6iGB7UT63mo=fGe-PQpOwMk=9V3 ztNHBe!A{TP*ZFqFUbjT9D0<`s7!UM|^sK$q<*R&ea&^Q!3<7+az>F^={>)h>qZX_0 z8!=r<>P}6e2chEl?c3nnw;umBQfp~x0Qk#d-sFyhWNx#>OY#yu14a38$xj}`j^qx1}{)OLV`nQE>P`bn)Xi8S4!{xk*+AssI(*GhS4hROGL`egJfF}ynZ2H=zWQiW(dpYRciQJ^s>-M3Vo3yP%8~zX9_)-<+X+7BER$4QYbOh zfy#KnvMVn%z)Xj&JoKUp{ZQIt1r(YJo~{%Z7b~ghhst>=fPab>FsSYv`}%8>M+zB> zX%2k1&o6#7 zKUB|CX@4;2PUQuxn%9SourLg#$9)d+%A3Ms^kKS~KQCcjrl61SB+0Kl`woayb12>G zF1mYHL@u?MTtd9ZtXppb{}aZiR|SHk5BRAI5kQlQ|Jql#KmXe)VA>v@IO)_sI?yBC zNH6KLfr3K5zH6ngE31k)uDpqF-#FNm+D`Z>Wpox>1wWM*ON*36L9**9V8W~^>p;s_ zemh{+=oc@#Y3_dEH?;xbSH1d^q|A~FVWN?4;iWk7V#@Ee@dCQ&1niJ}0B26 z$-{rk%d1{`C5Qj4=gz%Rr<8-WfG>3AhIiW)7uUH#z~^gY(+8Gq;XeakuZ}^dl*}%| z6uL~0KErlrC6#)a^A0+t?8~6z?L*t_0a|hiz79HGhTqydN?M;w_~8W|`E7mTZx6~C z-}-Y2?=>%F<)`_zL@qrai5t-8#YWd3jS?qaK90i)K1)cB#pT}mP$=c4F&D*kwn+7R zZF&)vlZEGZ`%O^7K;UsY?XeMBZ%+0f?6MYae4;SVQ)P^jNsN&Q!+VZSM`FFsKpkTqy6LR zesU<&@P$BcGQfo4okOBA((_f5Uf--^Q7P@vM9Jz3ZF=rHf(fJ&&bG@*$@Vs5$-7)h zclHGiQ5*!enf#+sEq<_!IVOxg=idvqTQd9Q1FJIYTx9WV_3B>RSlXtWf7%!qBSk zDx%>i9SzUy#;+_9DGk1Oa%W|I7@t#8$(a=3y=Ck zyt9pB1Q!K1qsM9HFADw&rQ|L&x4w?aTb%!P&}yi^|LD9nMben7L1e@7I=fmBsUI@u zygdY>Qg{WHo+`MZvCNmtDevzjtc7Imm0-U$LpbwnX~-bb*dcIxw!npi-dz~BvIgWA z*xb4DZI`7rcfL2?5hH6lqoP?S+=^~C?3 zdkswBnk@hSbMMlcUtY6xsb3L#1Nb6u4T^YupWK;G-gfc!J}FUp+w%wjJrgGkzmt)C zTEpg3T0gLPZobP?Z(8Vcmpe2K8?O)1WWo>IR6|!K>hPm@_4B)fY8#7+_L+czjC4E?3 z`=83=WP>F@QmTNZvqouNo|MjbygZbSg^E?Nq`pU5G6hQ!P#<}G-0T(F?`*%U5_!^j>i}lZww69Xqwc&x^u{2Wk~4Rd^#${ zFO9{~>*Rwq&9x;{t|)f*W@@_%_Jqp#T#F%lKS+kyVt4Lu*uFz1AF33|xX_REp5;e4VIvgsLQHpiqvN1faC&9fhY{ z4WLQT9C|f8jZ%04EaD>o1Bn+ecoJ>x#S3{_84QOoP|p!WLiuD(Tuq?8iy#rOKo$uC zF42ci0_xZ2DRms0M|THq1|OZH#coh)Xums?lBolH=$*p|wM(7RHXf1$u)@D)d~&q= zGMQVLqzbtO@;&OH0jORYzHH-3BB>;dReU3Lxlm6PMxEl-Z=;UxH9MpI$asiHmmhhF ze|;U^d5O*_G4A)F$1uzZzt>FMbh_OHTKT<%KT33fpq1>o*_fgWRh3|E6X4J^_lr8wZ^$PG@T%>mxUe>)6K3Rg>L2_w# zVfSSYmc8^~GP+Ejq`WP*zSR~>Cxxw7S0J_EXKvvnb!WnD$w|3|*G4~VotN;Rm$l-+ z5;DqO3JV+WmokD6(l<ZD{0*ofe6N>XN)`G_~0WSgZmH{&XQZ`mMV3sq=cYR9*bkDZsLP1A4us@GnhM zTy$2v8xWmS5S>#r$~r`6SBlOi6P@HamT}Vf;T-l4@J~;U@2J#K3q=PITFfq9cWv?L z!vOiOhDBeC$3ETQk5V9a*>Lxzi;?Whe$oF8A-?XGuDc)nr4IBH1YyA!PcXVA=EQq@?BK*eN#3AQ+qA!DF&8vg%Vi%iSs{&Q;%2A*NTg6>`5~Rvay%s7# zd_XHHZ}i(I5N4yLC3!kPwojhgVg+*V)FV6#TQqU~QEGD7Myn@M2?sX&tBbmHq8n|#b7;Dr4 z>XhUW0t~$Fk>N_<1U;0aQ=m8gWHf>W0GHk89)Em4Dtzt1n&IJ1l+!c3hf>|Ezum3W zb_&^-V>5ZDy8C9Q2I+xJ#|s|&yGMnO|N7dwOJ_dbdGW3rg`g$AnS`KK#n5@QlBhBj zjR#y-Qpej&R+0oMcV*JZc3`;GM+1=Q_~7F&zdU>POx+quh}%*;sB6)k*XcnHW?l1p z96T=U_2FbZn2ak@vEW5ykXYXHVXl(kbSctI04Ud1Bb`T<6(stQ=&?}BI-3PJCggI| zx~|IgmLx22IRkK=#uz6!#}pNEMZ;w8IhcgVyC5eaUT_{hJ|~=#6-&CPkgYgAiH`P zsBNCb;%=%LPr0(kG9|9*qLmaIyVdVQ!)|7+zUr!uvMc^4s{ct;%>lw_vwt!y#4r|i zIP0sbllM(xQWkF+v2p}dY-D&suK!sRVSq#67-JWsQL7ENnmU82GFB~>wyJ}jgHgg^ z26|B2S`PlaO%37C%8Jo@9!fm*&QmP3&ijd5uZSZh5VT#>Ai(J05>XrJugv>- z;=GGj-38}6-YxXsy$b9@RX5>#*9dmiS|u^-Av8~7hOnfbB2H&@dtmoQDQlFzXYc<+ zs{Pky6bD(%D2?r$p-moHW$-PBR$de+_xXWE=HNY?uA>Q_bAV=gKMnjrE=7zyp?gKX z2oMcfHw*>KAUPF4Uup1>iE4`pTy)B}_UEq-)P3{rcy9&d!FU)Ju=f3sK#x z8N(`H-HHnD6DwSgtq>0KC_)?yf$z^md>f06%CjBd1NI6>Z0KLk8L>CtH)8iO9i&P{ zg~=oKOZwi{V=(UJq1g_v8#!&Jn3{j+U24QB}^qH4n|_?OXJ*7Yj?1&8>Juih_=b6Q)j~hiE`Uw%MC|8uw$i{K3B^^Zjk>%%ga0f2 zRTx1^nPz6rX68G37U|b_^lCIu>vduvbOg`$q&%z{>a8Qb6#B}2Puu%diQ~GE+I`#3 zbyrrLQKNfisIc}|R^;g5(z1+YN9NiTDzp7(RAwhyI>{F$iYsGPX8Y)1E>2~(6;_#L z{tG=b#_Ok0pNrS1Z5cAMrX|;XcrsPAhqNby#_%k%pfHgOesjVlz>vEF5azHv4vUzb zv@47&i(koYBG8yvFz4|x40cfY+*}Y8!1hb^cxc0)z;l+MF>QU$b~L`(-(E`e;8{~u zqcgm>sI4*ar&GV93QjkIcJjC<6_`5%-%!Y!i^OsZb!2=y`Np2`65r7(Q846AB2x2E z>D%Bg@TP1kw^_F})m|5e>RN+4No><6GVM3LH~PtjxXf3*B#TBU-;^;)cy6Uw(@O;l zHM!J?=gu_)*2u})oZmk>;=#2UjP&NwkRo&1ZA}2w|2iHGfz+kBb4sh{^1&Rtu1&fm zsoLqq8;z#YE5ns^%9lf(vJ6PkT6Fqk(5_pgtcr(XJWW$N*v|nbKIDnG25?>md3!LK)pE30Sh zj()72u>$>AKZBLSpT6i}t^ohrHazuQMm+V@y-U@M%V(N_FN`rwfrdakpcT*vXu_Np zSROFQVl6Xn!;0Jd+IDZ-PG-#3oZLXR!fPrufQdA6yfC)d1+Hmi_Bw1}IW{$BX<}GM zTK1zfZ@HP;xMNxCTQwQW%Q)e@<@ih6L~xuYcQj&r1-X5sWv9~Vi}twEH3-kwWWOq7 z^s6!^Bl`(!nZ9mu(|BX{Wt zhO?4EsFxkyD%Om)OY33Iam_LayJq3FkCnOtGy+Bv+VHx?uqmvG+Kt@Ub`b4h#664d zYEyUj!ssq)!_=X>byQKo?$*ymw1~>H{xG&vR)^7Ftls)OulN|mQ5inO-pPrpppUmsOQ2r8k2|r5+ zR#qtb3_1bpW$V>a{&2TktiiofpG;4tM$Oe41 z76(|aR4llO4Rcf}9oDf%-boWevXLPrG=u#q4KGG+>UelP9Nod{hG|F*V7gsAF*%Ya z^EwMGBOe|Q4^cG~^u?>EpVU-O+V4K_!`2O?_itZ1LY{KFe^e5zk~=GOokc&Uk|dfs z6}4Es1bG|f>Ifs>bm;>V%lg_Jwv~m3jJsT@0$uOVFtXT`by3KJIr-=@{P-BnP#5 ztOOz2h)Bz2l14!x0B$8|JTy$xOBfjqGMGE$z#mR>$^`t5=Hz(MS+)S{XnIbyF zz0_apsM4suHXPx!U=+uQ@o9NkWZT|a?*1JrT${c)FqRP4By0PdeiJz@v(*<_u^w6KmHUS8|d&?&rdwsQ;qhGiS`#0?XM=Su8m&Zqyv(XNm-{=AJsf={mnIZ?bR&ze1oXi7My2_D5sG-T(F>~-Z7;k`kyNLgZS@U=llG?9-Beb%Le zWGe0z!bz68ly)#K4Zr7LSekx#C6UjQZflyf07s69RMnriOh;G?7b}YfC~mSJ@)fiDp zIa|k;fLrrsN+yhX>q`Mo`7Ryq zx?W?I{I?F@qURy)2QSsrrZ6vk5!U6d-iBVVu8jr9Znu>5gJ45A}X2J|3 zx0biYMyM^02A;WeWe8?LFUxL*hf zn)BZdb3PDPEZ*?(;Uj=Qx|obLVR-5l71{`c2tq(ZxOBo>VFaq;@Jyt^)r=b|9q2r@Sx|daE!JI+@Ee*8Uv2SQyg@XIgrLf&HDR?2WM~4#7{Yjgsm+s&k6iA2)$*&1tRVaK@zHOr@!u57Qq{L^)dy?=0*G4S z3rkU%oOCr_N0ZgSk@5fo(XHL`I}T`^4)wp>bo{-}fB$K9Vga5v>`u8SbXwk*N zyy0btkFY)4**DL3HlNs8A_cyX6cI_)&amfI$`2rW*`mq4uH9<(P+>SCyB_oo@EoqA zzCboKyHfp|y0Y=@T`44WC4#FE+m*uK)Ri~i-j!-nS0cEov0XX(MmpVlhE8w)U^?CV zQFOZZ>|QJXjdZ&Ay>xmmv3$Ny$NwQ>+57v6<@22_edAi5J-3(-fAC_S{jk+Mdww)_ z{>J4z`+L^&0==sIhZgkgKd_<~=r`8*WSp<4r{fO>T=H z@Q_NqEcdNkZLV*VC-BPYW~SaJ-z}|)zatvwU9{Q6tM?su;uYG==aJ!sR(~dVe4JQ@ zhkyRV4Yun{q>DZJU0@5k%@I9Q5C<_iT_r`^G2d7UNsU`@q$Q%7QJy*_NvT2 zGOGNy&R>)H+eZFxI)7c}myP`2b^eCTKi1W&c9vwBU)O(EJvuZJ737YQsCrZ}x+$CV z>)P+?=eqv6vHGiO({HNHTLyyPb*bNVseen*KQ-uYt2*EKX;iB^eXX1Qn}Kyh{ajnq zrBt)tj}4l&D@e3)xwq+@20aZ?bAOr&dXgFziM$Y%dJ^CK+}*n0r1*2_PK4$LM?m&TwEchHTy6e@Wb@2{NHZdhHTq*q;0MLcH8)QPpvCQ zS~vRd&#K@9sDVe32KEQfa09z>+`wrZH}Elz8~7B*4cx?W16Og}z~}kg!2UDbz|u3^ zz}_?5z=s%aAQ;4O1O6a}8yF5^xPji_FLDFZ!NT0YWbi%QKx^Yfc^{iEx8r~ZwqY0w&b4^L0(={cllF5wN|Z>y~3DVK04vTwoOo@h@;=;JLn%9-$v18%QL~~Mmq8)aJ5$c`X+e2 z_Pq32nzi9$<4nXw$c((v<0=Mw(yCVYJKaE+Z7b{WbLu=m&wK-96Cc0YgUpCwe@S-oYIxR*ikqFqqAJcd_v=1+GYb((<1yG2d$$zPjXQ-C*cJtmPK?iC;&)6x4+N6 z^z1L9HR^arumH39LcMfSlp&I8n%-lWxar#=tca-|+dw-X7TOMUqQF20h6Y4g#4d%r z2~D1pgK0&LNo<=FUZc#cKs3JLpXDZo0@}n}h2(e$zAIy_rPU8Fb$n9HO^wplK2r$L z=Sn*@8}~=8j&6y)J^VS_!-ws``reT5iJTRPcM) z+GsXuBSYZhz7?)^1vGhe7FzQIZ{y$VzyF)7ERwpk@(wkyZwY{T-0uaMFF${A$SE7_ zZ|(j0)vxHUbs|!F!%VR9E0a@UvLw@}d$!ifT2A!;%hCfzPYE{D@6v8Mm3~S=!jlXC z`oN()ebK{{y&6F+*cj23YT41*U)2_0g9@}<oS&+fQL8~3W^c;`J z{-n@Cjn|bgKmYt?Wy=5Hg4WFv8w8HEmL0>!h_KlVZ2?$MYNs{6pn-Y{osyCBhBql9 z6=-Asg?*96^0;o-&ICk;gOKN&mz1@7_QXVDi=1M7Vd-wIU(6p&G{*^MSes9=qO*&TA0c91S%xGw3_-)L{7mBr=UVqSQTbcJ%Du4OWN-a|A zp+5^It-h606P9}I>X&|@P!XkA}2S! z;;*FZ8dFAs{S8k*~07ANU3@&w#jbRV@GFqSx+`;Y?rIUH82HB>UAM z5-h-!do#tyls}CWxunwE_eWpWkx2=pL*5-+IMA6itS_EHsltPj^8SHK65X!`^soQK zmz8qgfKJ0i5ymm*(uu3?fGDVFUN5VxCJX)ExG?MYw}q+bX8M1$Mdfa}NoEu=CZ#Et z{Jr+jU^@+zNMls?A@QiRfsKvgEX&Q8GnZ2*t^>7!?NijS>+^A3d!|Afa4h41n%=0jqdi5jCt?!mQkA& zFBzaYri7sAl_TXn!O#!8oa!}}>Y;DtwDIoR4?Xf>RJhuB6qIoViwK7+b}H=c>8n^k zHYp*YP{JHJkgv!I>vLI_mm3jzN)s+m3VOXQ^ z*r4Phg-WHmjfMOWOto03H}lnEKGcq?-wyIXXJgw!Mns_kM`+L!3;n)$PznLR_XoXL zST%OynJ_YhVhWObD#|raOZE5hBNdv(XHg{~NFJ1MNj)~QsPU>UmS+4~DwIn{M;P<= zsGL76Due|qey7n8xXxi%>qSbvQfX#*M9Bvi2j1)d)kysjoV`@;-&Wpc8h_mV(aF9( zTXEjKz8vVY?P6r^KGmM$fYk>QwY#(7bt?V;P1C7vYnnRueK^p3^zhX}sFJ z4JRWw-TI@^xCsZ`B=}>x0tEbz>B~Pd@DHpVNa(>Y5B?)|7XIci2mX5-llI37{15(M z+5^nl^pD!v%BJ%KXyWRG@iE0Vm4578-VIpZG=9zx!Zr%Pe(OuL;;fO^eXG9EnK7J2 z(-pE;5Uci&hHUs5tkrY_PRI$IlV@pbWmhZZa&ems9Gj)X?czs(oj5Te?YH{cm(v&R zxD7ZO9X0$(xpqqgAO~;B*~(Yq0zfFoUjS@ld!Y(R>b?*pCpQZ=aA9E4g6H9T3yo24 zq2Biv9LnC}!!%o{d9#I@H(RiIvqg}H%_A&kXfo+IW>yF1;kLi9q9d)=0~0KxxAIHl?rKF zjx@RhnqTJ(;fMZaw9rvuC+$XIm)h~L&01xr9#XH8 z;QlEc`FbV3(YjsSmalsJrQ&nXjm2VIUymknAkE_w0i`Yjh8k^56AvoeMPS%=%D}V1 zq%7J{tAP?nH7{@^HDEiY0bAwb;WqLWhn2&macYkS=dgZ6-9g)pDSmKVu9uF=pR7T; z?8btYY#Bi_7An8Jo!pbMb$OF5=B`@b(-oF9{iLr2BM7mKwdtiT-?uG%>t-4(X(c*A6XoXyO@ zYp827?%!gSb_!wP!f4#&EDUp)KQLhq@x|ye{yNWO7;_9An;9UngT#x!zupV8-V0u@ z<6@72Q-NXrVf8bAu53kMIIb1xh5(nXT0MVQD3TDx&z`qn2gCKihTO{63-4i%g@8!r z9S;eY&2ptG;Dya$1a0Y%>eh%gU<_&voq+rRZEX|F98{`D??su})ZZChqFv<0DAcB% z%5EG`@#}b90|HR9`0;36Kn_}C8wt=Qk;UnZoy!SV0zi7D%QO1oLT{I)tEDd88bu)T z6`g$!j6ein>-gYEgK!545un3L^&nr40jr!}!6lI%Iuc4WD_eVTIMt5wYE`My_15qb z3DUgcFk!pJL#sSmrQ!_$iCLtnu!7-=TPPktA!A$zz3CLgq((;npj4}sPKw4LN_U0# zp^-c+)hhLB<>*rcFgofAR^!Fcr;|2ZFe1=}axq^mRPyy0;Oc00*#)vbO)k}}R*rYy z!==6!Q~of1LUrNr)b=L5j*lTT+tI-)RZH8&TA>I8BDO%i+iPFPHr6QFtiLZ6_U-0Q z$9@|PfqI0-RBKk$QA zKNk3)SkISj;8uU!ZAF()`RIK<1oXZ&?Z!a8&(|aw3-G~>);XQI24uaOKdjM02lg%s z9I4-g*UbnLXE$y}yS_h6n4|Z_;$dWh5I%Xa^D=Rx-5MX?YFMNg$0u|OQjR^!CZrr= z39eymf@_wMY#Wjm)8Y>DJ zP_cy8EF2=U5=Ep$bWd2*W$XwwZx(EH1DfT{1tH7ZurZ|Cnjn)M1#2~g&#LyWNuT5nn zwh(v%?TO-v8^4%hk<-k=q|Y*i!i0=J-{LStyA>&veC)*{G!MNnQoC^M@nPZ&9Uc-} zq(t;kv9QD}g&=1B`7Kv4l2c;O`z^ZS@`%PS))apE?=Dx2=BY5|g(Z$(m9GeZK~%JI3)@Io?9O zrjniojCT`)+QBQi38SQ&#bFDOcEU`Oka0c>onGk+klvs8;O`G-^p+mNSNdGc*MTq` z=j)nt9L@&xZh15ro%>UBT-1%Uc~q@z73Bo=N0+ThFX#?>?QQgI&;6%`idA;Ei%0eM zTgN++=k`%(7Eg-RTG1+%mH~+dt>6v$q3mN z>_$qmQQ=IkIMf>Wla`D|VrEl7#NMU`8@9qETpckiv$0gJ5e( zeL#X6S71H4z(#C=jidtdun8A>lM48O6)u?K3%rvFpDrmU21#4bP(QY8OsNgCRJ6s4 z=tpbAQ-bTxCuE*-!MTC?%g(u@jW;s0LZOcY3{XQ+^v82AUx))@E9MA7B{6OsO-MWh(qF$St$ ztku6wl1exG7y;yeSho3(66pT8i}vGVs#pIBR9yHtN)tm?Lm#;u!~F=LgZ{D)&cHP9-$=#Xui z-6+UpTK`iO@Uts?_V80k}6?>P)jbojM_rt7HHzP8(hlhgzj4sK4n{0+o_!=@zO zg3!L=Vw7p&-@|^Ug*rhkZ%6zZVIIb3z`PMp*%7~5UZs!aM);SUK*uQ1ybxaN>)sco zfU~i>n)0VVe_;c!G1C_-eVgkI(>hs3Duz)pQgu{q8D-6|@IjTHm4T%~Be5WAOZ^8< zjh)eE8s@9tx`#S4(xfBhrB)rRHANba{E9hl(+o_MI}R<-t5&tg??7Bt*suh}fJpp(o|i;l8xgC590FkVDxuh8A6;iLIV$SxKi}rB3qY(l%TpMCT+(>>z|-$xv7l!YN6?oM7%L?U^8;KktQg@hKU$Z9Z@F8o`)mr;eMsCUfb>#~W@o4F|?YoV(md z_?3rKxOF)kO@m&0>OD+mL*n<`4>AA~qB&)zs;T<`Jdt}106-AFx`QWX>z(ra8<~Ic z^yEBEMK~g{MQPJoDX?WrWGU37)!?w2cR!$C6s)eqT}v8qH_X6C(ygB1S))J>jsWQs zE%2HuuY&=_V5r4lsBsJjo-bl;z@nA9<`TF^TCF-F>qB*BFvnO2)P9 zS;AQ9nPxm#Suq^p?ECl9Sq-pLoqBHo!@Oo!*yNw)it@I3n!S#^J4)sAkNzdNN0dX` zO^$Sj!e@ZI@d$%6=^KS_Kr8D>g!8bhLoIb`^rB)nhY7DbP3;FDXkGd!;-19kkWZRW z4mD$Eq*yq^|3(XgtYoG#no6dHj)pQcg=#P{1}TS|gy1Gco}jG!(nxN$JzpRg#s`TjfDD7jKME$XS8i(?8w@a z<-kfr96Q#0ErP|KVZx(Ao<-Ibmr-V%m~|zyp5{*UoGHlhP#J0}q&7W;@*h@JZdy=k*D?hiDn0Zre`=sJgJz(%3DlMnTO?UXk zfO2~3wN++{lQvLzGTypRpwUN@P5AB&V5erg!X^l@PXq6=QKJ+1 zELYR(RmF75%s7j1(E55LGcyLD!!X*gk+8h{9LGo;hh#OTz%3f3S=x$j&Qh}}336sE zEiI(ej=bAl2HuA`u^K-lhH3ne5FWD#qY>!q+GSuz$lM7q`rz}SC}Gq9bj@KOo(o9H zA=l#|?XZ*_P=tg07_d(ay!%JZB4K{bqX4_g=iH;YMJmf%u7ZhRrY|2w0U8=@ppWb71*y%x-uI z@dnJU_@{b`WqFdR$WmQqP@jk`QDam}_Vz)5x`c?JaD%*hs^+pNb`(Dj> zd4z;Lq$TPRdw;wjyI4;9{z+`uUcf}#BH!;?=)2-^Z_!t}Sne5n3QfNNg>E_EMD|_{T zR}p&oVv|5;nT_2gWX3ZLTjGmKJTS5goCfuh2y-wCGyuLDvIn9TSUun8G5nsQr%@AX(n`N&o4P^U4VmTnLKAfE1Gnc)A@}*^&mjJIo}Z?g@*MPPb(g zFsYdPnQ8j&?lXfxx_iu~qi!!?2?W#~0U95g1UDi!>Y6kiJEM>Tl!O#JJx9? zxpY6nb<3cWZr%PykTNsLr8^0jK`Y%|#$Vf9L2xlj%P`4z3LW`9E znIyID5>s^6y$G11ucbGJ)s`5Pg)VYR% z*1ae#lQfXFmAVNyj7ZTSre)NX08(ihENcCf7r>z$UBtHT>WfAisTwq77*!Rh&14N6 zvVuD2ux6?;h9P^Wj=*fCYw(bD(+LMQQ)6IFkZtM9nozq2zUwM@e7u$5 zTrbJ3S!znm)HDj^i6_1gb~?eAm!oM`q<5zDgYe(?=K+ zQRj?6+8mkrPUv%|@f=HxP4JB$Mx2`u8!&~1^gMf%NRTpRLyGleO&BfKTa z-z==~W_p^+`aBKzVCB_?S$?Q2XdeE-@HyP}SyUa3xE;>x^rmKppcEmm;DRgCdP^9T zAP%oob0b#6W;7P7$6`&w^+lEb+**t#ATu-VpYOa? z)=AEOd|YKQN*j1*ji$0hUpa1tZX^2UpKXUA#DERy{Vjc3+}bV2_$f|1Eb5uq%|x&d zWFDb?d^`!95N_?b7;rB3_UsA-`|qo$5=Q_{E=OnzPyT?5-~ELUxF8;GksFUo&p1!= zohWZA+{W^XTDOK{x_i-oPue8hPzPK2b`7&$RW-0joKz z$o~j5QAvUmX?kcrFrQSc47Z$heDH7{YP{fq`6!^$qKc0y%kUl-PBg^`Mkd|YjBm}j z8HxICWBXvCWe1qZ1kzn;mgmJvUc*#kQaf zzROxr2HRs!tRdmH(1hGpNAfI3)W%*nPI!aT6*;9FAuT|jEZ^^EkRry5aWN(j=iM@^ z2&KisM$Vd@Q{Z{njT);dhLQC-9ss(nL}eD-yF;g8WAnzHRpWQEE8D~Yiga2VCtvW4vVbEi_v9x z@kzU6d*KXck{nMQmOlf%}kCiuLWM|S%_tD6sojf1mX-m6c5$N*i>oXW_dQ=yWa_i8Fh-3|;t z!kkKT+|oV#DO}^Oy{?RGcKY@@cd8?l+<4u_De?U`T9?%G088GxVJjtC&% zA>z?E!|xHKl?xoX;cgl$=x2rgWzCp~QU)`Wo}uW*gRP4*U|Jhk-Ow(Wp#bgPvsRme z*+~8GZ6-8oNWZYfMld-eBP257=t(V66Z;f_Ss!yb?#AfM>l=ZE zq3Kq$<>;b>H^AX@ea7d+9Wt&-<4)BuOpIapa}bKraS1nuab*Gn2^Yq|_}nz}UYR*= zPw0&6V#fETmHW!db9+ibG~4S?N#lFd%6(22veh&4|srqR|e9m;(n9bNF zYq9}fycb>%qmsxN9y;h}=E8e`G44P^*@zf8x5K1Dp*v=BB3wYH2kMfUo$r`K!Txlc z926}nuvYKFaWfaFPfN92WO+Rv{**O&WB8DDc{9vWwRxBDY1H7^^<8BD^qR7OH*i?6 zvcfKm2-Egxh+vPNJxIA(NSkR>L}7%s&%)2gXl^Alefi6X82!B!&W6)&?;=R7)5!OY z4_$K`t8gCVN_n@2M(wHCy;S`IRwCKx~DQTZSq_i{`Uie?mS58 zClye3Hvu=@;~|Z;08x@to}RNKF7j~C6eA(Mt)FG+o}G4m??JuQP&DBqM$&isJqn(T zfCy=Ifu~~fO-+=VhlNQgwY!S3ll;PH3ctoa+{Mo)E&c_ZXzSixwJOx&hPWD&YKX&x zl91^bcyT|u-_z^+f{7AW@~~4#8VyT`LI|w}g&Ny!^)I;VBmFIdGho7#9aBO~rROtP zB6^LS{I}K!zdtG2o4Y0+qPBW1oIL))FK$*+6|R`GsRD)0mOZ-G z&?mddLoeOH6X)%-`jDVU1gG7%A&Kg{A?4jTiOM zr>M+Ik=5a};NN-A>8s%p25KvrjyCejZ-39VfzudfX_)y*Npw!?Ay0Y8TE;`y4t>@V zKXL|3*yhJOa?l<4Z;ZP@)KY`rHK?VgYiZQZ=-8$Sc7zSqD!YXLn(!a&A$9@()#1M) z{C5xkZNq!+s`Du@gTEJ*D<&e4i1+{VU=po9F{jom!oa+i&-fGg^#~nk%+9>`aT!n? z^FGAq;U2_nV^v@htHbD91rX>Xn}sGt?bn#u_^6biaFgszMgv}*bm#*Jcx9)fNx$PT zYwAuTlXi^|a(R0<1Wt?{4`9_EO#xwRc-i+6&|vi<`7bkTuks4QA-u@J;r7A5Fj7bq z8%^kOF0vr_HW}c9M`md0H#N3#9MSS;8|^~_VZlVbZu?VwRW}#g^70*;FIzZhI-p*f zYnq6-<@wKClKN!99=x|waCDlu2=8G5HA9QY;%j3U((?;Lal1s2^VvK6{WALtQD%|P zxnDuC^TH~TU~m@XvDO&iLLY?MsF}APMR$zFY>@5nQvBbMI>{`}g<>xE=9NWfRUwES z3*Z9sho){`1@AKuI#KM$`LH~wX!RIzs&%CbjxpwAtjL-EmZ!Cyu$s_HpZZ1>G zM%a3|Kh7Q>OId@phonnP((FB?G%>|y@ga49shZ7)lnYFWW%VJmE;3DaACikA*&*mFl;2HbbYdwwq)ow%joa=*k$McPO@(L_w z^}!5TOAiL$Tz4>G;YA1YWv)1worL8E{f?|P=x%tS!3bKb47yf|Hhq{C_hWAtPAW^t z+-6;Vi4hkVW?V_c1{`=@ll3YM>1ADALin9UT|zG2)^iv75>kXq$OQ>;i*va0d(Y+` zJ7>9joshr~7Hx)bng|xqW4;Y-p`V?jLm4xPM8Ei;s9KyEIB=`c=Rh%zpT&L=UI$JJ;8idVEI&6xr6-2s z#XT2T&{XbhulBMu;EM8-dK z^v0o@6F3^Io;Z!>cWlV#*ATMy>Jsi_#RHXlP_4Kp&o#JFN- zC_y}E2_am|80b$%(CgUOD?c-36RjE263p+EOSVSJf0yxo#l0BO6f(Y-rmQi-C#=ak zuce-_Ot6;F+X0x7*J@18Y>fzf)J}NC^3^LA`e@?XGz0GowPnykP4U#j&p%!En{xf8 zJaV|2QDIqFYAw5(a&kXEePLHnG#coIPhWG~noe^+8{UZ5QxktW>d(j%vC1G`JjHKB zxu5^1H*EK39Y6JUEDSn+4z*3Z`BEuf=M>sV-owBuo5nJ?iu(!lm5QI{f=Ol~LKR-(FD-& zLOsz8`0-Yj!;h7f6!lx-u3TKeA^~Vw%?d!hRLusoKZzJF?<>{P=gMI{Uv3`dYc%B11U=XW;5u|`)__0jr!Aj}!<=QU%_CWFQ*SGuD~C;RmtDo2zV)hhZ0soNWu_=^?#7CBX&NFq%s`pJ1GTz zPv4=(Oi#==^c^dV?=m&-rH0@^bbkKn>F1xslBGYd)k^vKr_hqNK212W0fJ7mJaa$#tntx5 zb3YAP;}X6vhfl!T6HWCIF?WXYU{DbEw{f^$D}$;J*Fke@*AAyrs9l22d! zZq0(xF^Ox@xR-ka_5IFNrmY!{LqGI${Ff>PQx{dmp{2&w^tHnCCI^d~!sQ#85SMRjiJ{q8z=?A^>pfxW0w?1lcpGr4a zxl^2jE#dqkQy4;?a*f4hn~+~1leRTR|1%-D^DKZsrTff_Rm_90S{t~W(S#?i$!WRv zE?#(EekfdP2Eu*HkllC}UMPbA)z$QahyI)8xa2;({h0fpuckrZ-8DX(kvlp=TK`@# zEF3V_Rh)jNOtT27P98jb`N&2sn4L2o$opAcho{@zFC&ygi^Q+}CwFD0bvNiy)> z3-4tEp9~&@X~yBcsnsoK8mQZlM!*2#>$~pb<1~B!u8Z;}`i8%g>{tHa0i+TJt^0Z! zWWVD5@v8?}FY${hJUkI|??vJJNa1_R2Dp1Hd~Xz{M91MN%16|-u=Bj(o}r}FAn@!d z-Fz7IhC38Xz}-W~D3|Kv3Haa~AyrNR=}YSpiz;z*UktJ9*hE$gM27N2L=JsXpp8zd z(^_Jk1~?&Z=5I7dp(u$N=ZQ43tPMuE9oCbEo!TiN%_4H*Xq!WpR~h}LTSQ&XV(|7d zfPeL3-3b-TK=X4g;-PV(c5tF_(06dqMarKtt_QdjfhJiWKBtb9v|;0yLnU0$wd-UD%C??Ytr$)JjC5T>EgF(n6{hY$!Hc0A_4Ae-#SZ2@a!I^dmS{ zJ>|YqC)vvrHp*Dp5@d}NIZH>ZXFbT9p!$q9A&EaQq3FC;5aN|4I^e2##zJONg_+yc z@Ebj>6S}pQ*qAlxCmiq3b^tM}PRthS#Oymev3Lh&vIC}l9i7gs#`(Denmy^U&MR5_ zfWNWa2{Yx0!(5eN`q-scVyz2z;N_LR#6c|jK3wa2S&SRfmzIRea;QKi`cgp5_am`E zsI5Wl5Qi|#4`m^pB+g7|6A#%FD zKtG6Sy7Ag*{&HiQNZcUzi^<-N4AXGaxIW8$Fo8aJ2a>a7nCpFD1=J-e-jc4$6b?^+ zl1YmrBF)h9{lNQxr}Y6)%4rXV5*i|Yv4iX#ERqX6cp+8&CV#tdI2~}O4F$2x(H2Xb zMVn@tTOc@hQSeTK7dT_ul-$$fYZ@+k#-NhrB?1lz##{{6(hzxi&b{y=5D=yYOM9|%9j;Z1At zCddPiC!;akZ+brY9?l#%zz>tW&MQeR$ph2IOi&NB{(=>Dr&bs-eu7n}jDG7L`QrdN z;DY#a=$POwLoOfnr-nZN#l0wT2>tYrc|g;A;NPY4$N{ZX1blIqz2N6Ndhzf(kB>uo z_owNca`W5Fo#QwUKsW7h(TdGfd_yVbWr*Eba$v>9tHb#Yqp#d4&3qz$7Ja&LLlRYDPb&$vJ0$f+#YZ&_b%qb9A zwa87A$2(j{;?;?pm?hI-Bi2F*J&m;GVAS9oC;=Jt6e>C*4#*t|tm#_g;LPCnxrtl~ zQ*n$rj{Sl6&^T|Mx%C!n+`-=h{LRDPBlvsMJ9De>w+`Ru@V5Ye@8Itd{LRDPD*V0a z8I0$WP;#~`DsY6#80JKnbOb`IL&wyv$uum99IgzC>Y(}+HEg$_aAgE{ z^U0_W_xee&SqZogB%TH^8AvHtPK(uMxwunrLJD*>`?*-HV6bcqB?w85yI{G);%>fP zIw?{?qr6x-Z678wCwj+kV@lEjqx%G7F@uS|jO(v5Y@G0=z}=9VqcICM`vJ@ykM4&N zWF5BBgadA_9oxA=B}QGb~Qo8mz{~f74aAL1^vzY;eBtf@+Iu><0Jg#E4@}P z9u`VvbFEuRamyWX5YbrD>m84?cCSw>ehGze7~&vq$u9-$lg~Z?sm<&XipNJ>?w^38 zqrrw86Cur{Dg%Q7zn1_S2LckPg334+{VWjpD}kt>?MEx9j1BZNY&DK4e8Y&!3c{;~ z1`#0RRt@ImeK9!l7^v~OXk=i9mXcS>Uz&Aw*z=baWwjyRRi@$%MZ6Y^7&`K0o11dL z<+6kSj4j9+sux`Hx|-O`foK>1Q|Et*{Ex6b-R6Jp_@4ql@um3(D*-1}Lre#v2mH?| z|8vd%+?YJW2QHV_QP6tXgZ#&4p>nWQIxKFhP`#yt{BE&%d|0a2L_7|9kkB^b@1uxL zcuaUy3zqI3(j@3kJ1~>4);2Rx9;39Dy|D#PKx@aW4|kwDEak>8D$ zP~3b4*F+_Fy9@sS7heY6O&8tRetfi3*0-DaYBm39lWHtsu%3-=I2T|+_pikKCG2?adB>asuz(WwEW1((6`xmF>Xg87C0^`k5j2B_*~l|*h*VrBFzaIt zgN3ddU%>p4_RCbMW#^QclQ5sUVb{Tjk1$0*VWp3GvB)*?;X2=`&b>;rsI5#x!C z-y+sfT}D520U%Fib~@iQ)Ifg6H=G;TuX9SThQg`My#dYljyF_B+FO4ZVW#_e2iK z5Ci}iU$ooR{AqKinm;IR9q;TEt59VJhS*3!U`Iel0mJ1vG<3?vXA5QUESt%1cry&G zvW8Ly=L%n7`csKsd@$8a_oNyIKl+Ar-tIA9ow8I215F zl`;^xe7&A8yvKmRtJ<1whQ2;vd#hr(S@5GHU3@WQkH8$|_V2YxVr0DsT}h5Y8Xl zr39`)QYp$ege6sVMlxI6z?S&^4>uvumxrd5JrEzhRW2TGJH&5E(vJfArW7&sZ6F|V zWmr;sZH|)LcPt_6%bi+fP>rD1dwjg7znlrC_#MR??m9E0R~TGq00vk&0K`^`n`l{F zL{IR3NM(_J)_n9T9QYZ&T;eBePM&quEBhvD6Qu=qJW6N*E#CO$WM*2(O3xsRK@n-Z zyn!YMo~BT|ZmKlAZS{c^%FropD$V3QmQ$HU2Rk&lKW@lFDE?CeA2Z-Tc69A~O6Y=O z7^lDU4u-ov97K4+RPg@FxD4$=Tw(8H_LdqbAia~|3@Pvh zih3^a$i7F>C8PUronMEGkB@YH-4?gkI|HRP?lZr!d&c13CHfamHvCgT)OBwcy1E4Y z1d?+HErlxDzLZrK9HBQwm(`MipUW%(aspH;dx`&?qiht0h$NRN#4LH3z=z0W2=0Bs z5R|oh_sxRMOt~TEN{ENc+Vy*mge|+?i(TT&;NNmM(oi`Pj%bs3G#7}if|bSOB*^dD zq%D7LPlGTN_f@Y!t#5$0zG<-Jhs=pOyfnGZvX)VaWYYK&$@p6&lQ2ajpJD)1!SsrB zl7sVfB~~v>u?D5*Mhg29ka2XdXOuS~4}`-~-9|(H!qivQzhG9DQLZvJO0{}@4fr|q zNeUIfW5Zg>jz|6b%h6D%6o;!VyQMq zl^g=|tTDJ%Ltx!wrYiK`ZV0=(>%k@_y0+w920)>6OJ>O>?*Uc5ToI5)`W4}yPmD@< zuwyezQU$OK$AY{Y(Lj?HBX(gorVG2&gFm@r{A&rICrD{Tj@Y(s_(3yG=SI3X-Mkk0L zvA?HBC-W=&v0ZD~!v{ys5AVPa;Cwf*V{)QkO7f4TXig3CAmJ;E?G}sCg3|1^?PR2 zven~e3sBDz)YNRA^90hSq9y=yCVOGk{2AAP7F{awgPCOT9cHpAc{S5xxd{`%I^*pe z^P$qtNn-HWJdsD7+yO77R!&6Np|7@KaDI`JDlW{_TzRp|;!nSHbV`zd>EM0f>#Q5Wk+b2)7^s^AK(DY+8aYJ&CLCN*3W5jL4h9R!4-Qb=xgTr=j*=%Tj@31(Y z+1+Px46eJ!G?##ps`ZhM!Kt~X>hV@Z1}oeOSj-86VW&-w3FBs){EhpWSv;?M#Vr05 z!%-(NlN7T%p7nE2nAmF=E?aISjFQb&Dn17$pD!#?*^o`ygtg?MIr4%?R6TAv+i7x5 z(q=G{Zlu!ArcjAn3|e?F@bK0%x=0OMx4p|249dIoEWP<+&3#<~3OSo@O-6T9fAad0 zD?BSOBsP;g#<_8Xjz%p28W2|2=m@FLIFd8NS2$$VX0i#m$l4Q(2Syw0Ei`0#8H=7+j)H46I9{d4&HtDy`9%&d^c!)l~7EAI1bx?yXF7_(f#-J zgEFn2VxP3=dH>H-B7##K$m63?miJ|TVGBl;CX`#fV9*-JlrwTw35xbYWGSYA&Xf!J z%Cte;e<_B-Vf7%KA;u=xF`3YgcbT~YVD$>y3B21)k>+-!%0VaKc)cqIKRG53c5f$$ zEEanGq>jP#B9SLlEYX&i=DM86nXia(!D+n#>dw=?!6e^#jGU*l3xs~)+{LNdj zl6F$T2y?F}y^bl_v;$4!uPM9-X&`8=bZ?kCUtV6IDb#*cuil1YvR%C?)HF(+_b%r& z2CF`o!*;G0`v8`-+$rZUXhR>lNN!&|HA7yW^Ef7EKBSpp9Zf{NDYYE!mrbLu&8XUj ztAIDQ6F`BsDj-tbG2tE`F|VL#G69I8*^KISxMq@RN=AF0?Xx|6*Tjd(b3tB&WAyVl zujuDzxdmno!vGG(0j>uip{e0$_{#shm zkOp0Ow@7tvNhhLO+=l(J!}TN3`yYl6$MlW$9f$FBa_nbiuKlVqE&Uyt{~ORIg}+%k ztQU7l=VD%w<5C1=?R}+c)ENT-sC9#NzJ*w&hR~^W3rR^geK&q&cIOVw?sH?aYYfir zVq>%W?BMJ^H#)mX!?T+(KD+S)v}=#h)`A__dcFr+&vs!eu@75Go!Cm~#a5^r`9=GY zU!WuT=X;V*?n*wfFZra-$-g6qBHU5nNpIYYRd~Yltnx#Fsz#BN z+ux8Aw1tjpa#W2SfKuu|q0C<9bx$8PM(*mSq1=I3`+QgGOTg{EYp8PY!D zH>BHavw7#AU-nDGUf_ioC&AM1K*iJ1Y|{4GzEH~Cp~CwT=bpFUKuj{m;#qD_2S9xF zitX9q5SN#0P(9uQ(&eKrFJ2bi2T6~8@F)9C3y%Pz}+#U(L z$52;TD?5PtC-+LX^wlffj)SCuJ(ubjVs=9bhPkEgp9KNOP9l5mNJZ6sZ#B37_Sf7# z8t_I8fmQd7z1Y}4b5!v?D8BbL0ZgjC?g4H&u%@&#p;%+@%n|Mv7BA%FR0dJYa}je^ zqTrnm<1j!G2i?~e8wDpcf^jgi|NGz8|8MNPy$ipu^GHoZ>VY9zGHTJtV%w8Y%D_vH z3uZ%-1~39>4r4MD4BT@ajw=&hH)i%i188;WNmB=zV~;i zO;;hZBP=>i$`l51;>e6a8wjyQ3Mme*6*ww`VQmeUtk+5fH3cazq*hO5!|u7|#>kB_THlJaq7rb$-ANYjD8jYN6P-=SN+k#P}D zAXiTMGbEQWatvR}LZeS3?f1r?jBoC0GT-lA4hJN}RXN1=Qrvb-yc(gaQ$30wI6Ed6 zv3(kaxs5z#(FtQ7EFxRHcb`kg=NKMg2Ue{31eQx>$@=y^!88$LAj3_5gVb)&np~r- zZZt{p=Y!PwEI_Ytgf)foH^`g~JLn%y`hD0Z{SMq%$_w0ItB+R(tGG9mm_>CDpE5fP z2UzOTKlzr%l4T{e6WZR)Q1CMOvXAqoY>~kaH!8VJ!dz<6mIc9os%aaG57+y@+NNQ! zV55}%+A~d4z6Bo|$7F0$Eglu~b=H`W#Z94{KR7}Sg5vgWku^#La!{&PD=5C>uut?P z+t~9lPZ$}p#(CHHY#x-3&~i@YmZmYekJN*a=oQ~|d(p3)uvw%7LYwIOT(du|v@ zo>pN&)YvqDI}shiXA8jBHGCc5Gv^V**z;J!SO+<_XK+_F?&>pbF^qRFv5cD8=gMg_ zVO~zoP|~F7!R$TC!-+0gR!Y!Z*V=Z$-mD*R8>9y<0=aSxCNb z9lUMNCTNI}*UXqA@`luJUe|K=7{Y-7q+2hAkInpHsaC01D@UKmRScId0Rv^WijhOI zgVtBwkc>ldmy%oRnFvg893KNi2#GK1=drRD5)GIcFIHih&2hGOr`}rkp>8h5$no1e z7iH`_xjhs89_jj!(#$^FQ>CxG8|V^F%oQDyTIS(A>@}{=EEM?tAQjCcrua;Wcih#d z=uKv2h3$}mA)?Wupp})JmWemcE%{MBcwtp<y&>NL_$;PEGoqY3cPlb%1#!1vu~ zf*#ll#=YglyEX1HXpS}9#JhqUE`DoWcUnQT+~Z>h_tD8FvJi(wSeIMX%4w}wZEhEL z^2gm&+{XXgy`MnH2V;toR`^}wl>8SaM!@xv{YghvCQMGsg7)wXxPeLzL zmW$r(5>VvJrQJic6o*2QJ6=K=vSO^kPdo??g`W{obxYWYeD<2SBJt+JUaYZc$g#bX z`|S1o%q{yY=L(1nI=M!FgFw~9rIy*_J+@)!o=dgep{u{!&=r~W0w`gjh)B4d+zt|; zTaKn1h{kN;#0n`pJH`*Y7b8ivA1lx0;)x6ZC>my~q6Lcs@ri2m{3!8cCJyy4l!#>OC64WY>0hUF`0J4)jQ z?aVATD3N(%&vlS%R7a+dx9u};+V{`CKwwROjr$R{iJ={?P&c9!;Gd=YrfekNue7!-<=A?@dK z7NkZODI2Zfh)}E?49nJ{w}4sj@*;RGlkuIr);xmqqF62xVFrMeHD@jiOjVLmQQUy@ z?JI~!vG#f3__U<}dvE5j8}#J+ckY=r#D>OV@-t=+n* zw(6!FwFHIg#fiQ#SaBNVi_(6D=0CfH+<(-O_Y~#|EV{3$>$ed9$WbJTK6{=lX=`7J zi}sSlMKP~k3(1e9vcn$TuJ;V_(UmDZ+W!XWQGHSAQ78C5@zF_~^oZ1BJHh{@;-eEe z_$@AUiQGC#qKS(P`OKJn_Sw?_xRwoILxKT&g8~Z+8nXoSap~=^xh0@0FIwmU`ZI8$ zjioa!#X@IPFIKrA3sv7_AU2o7ecse?{D*541=T0hk4S z90!rhggI9ayB>|Fl+{H}yj>N;-Uz%l3%p(QRF<=^9e3Yx?TGOoyFwlj`2}0_Vy1ZM zJM^@+=v5>U`Bo5zdsU~S{b-;FP z7=AvV!125jKAy?QI8?eNA3%XS{wy_jiJAQj4W1bKklrl=9t9G+ttrNgMZ`*t^+CO+ zDN~g-CX7|yy}P0}G%H6KphFft(AzpOd-2ZVt=ln-5<5|EZSoq-yGWNudmWhI7MM_b zOLm5GPM*wfoy}49B65{p-!}BcF%XYk7ANy__#Ux}jyP}Owx0?26MFv6o4aC{m-pVr zL8wqapGk8luAz%G4JOK8#5c^7>AqcG#JC$6OT`?u01vl|RXvzuvbbvytulLSS$x1v zZGU-rKlEC;xlhZR`-Hfnhf84;#<8(IGS&~JZc5uN>EuZJDR*U-PQv{}^OKXaJ~8?u zPTk0)Tb+cZb;Tl2umkp!m|_3!^^kyX zp=pdM`1JJrJ`3&Af}ui6x6=e$s-Qa=-KEg?NRd05qur^G+=h(9?C-F;LbQeE5oHxk4Q6QW;ip z=uwz?u^%FyC?c?%PC_Y~JXGM~zY?JM)DoDOWzySC!sqElk%&y83Il~>Nq-1cgb$X= zmN9Zdh#f{^Hw&#&A=&LY-+f@l&|^!$xQ9+qxWnLQPq+nenUeDO&Mf_a&P30hzuu_@ zaEi`FcFghcdN{fprmW4vJDj%Tro`BDGPDRwARi>Rkv4qiXrE&4GE%Ix_LX5SW2Q?C zl(x-PJqxXV|Gd?{M*0w+lW~|~gPU=@cMrmdHMTX($c#hB_MfpU-gBOSF3izQ-Qy;M zamc;Br`Se$`%f|EvM&&}H48@hK8EQI{B4tef&x2Hsu;x3LtFX12d6@mk^?C$1hK}M zk_AXng%5GIm!@dbw8mZFC`d9OWeEnZ+B`c6Kq}^1rzAxqN+`k38Ab;&*ql8yjs6Rq zBr2!IR+W4H0KZzCTiauivih;?dj>v!)aMWRH;#97u=oGsVDH5a_5vflxA;i!vq;&e zZ@e#^sQZ%5a-2K4TSLve8D#cjHz8B@xGW~@l6?li*}h}?84oPC0X;wDPeGv7wq#84 zLr(5|9;qv6hC!PP!}6bhQs9MPPf9x})Kxure9VMd4pa9&k{40GhepQI6W^IsqqTN@UBeLTo1+@dz88;LJpN0yt0JhD+y8pn|00jT24M%*7^% za$>E?Wgfn-FL8qt=?RV1ceE+CAMx;fy*Or5;G(#vTk!UTH{(IQ?1`sZY=e^{QC8AA zi)KdcJmOXqKfXCXI7JEmRUkaUtQn)3;9?-YpW5m&V)TzrYM&!N&sFL~CUei4L@|0W zvN&wHM6c^=)M7;`;p{I%}D~p<~?yXQ15mSG)sIl*&V9LRK7zhYRwCLtlFRT@ z25(YA6O+s3DJJz=p2 z;Nq=HZiy+mi-b!^YKuXa=y7XRQpjgwDl9Ne{vu%<;yad`Gl6`G!pa-B$}6~RJ>9jpdq;rhM6oJG`rKy?B6ch8LE-k0HTXHqQ|XkJzSgkoOSgHR6 zlE;_$HxjC(Ay!Q4;)}R%o~VD}K+Ju^x^LW)ijf&5Q#+$q9yv(wx5oJZrZ@sSGG?6D zP36?ykVSk`lny~ZP^LPYO4*&Mz`JIJ!8F>?5?5rtKyqEtBossfx#*Jb4N}HG&vIvD z8OIKiY5BD>9la4}BQE_UX@tvt&T!u!(aJVl@S6I^A{k|)d%fjl{Ck4lYeIggcO339 zIpGN4+nM)#4tzjp1Je>9}hkj@4 zKJe?%v25Cz6QcS5XYXB?+eVUw!QV4aLF=321IQ(slx(+~G+H4`vaPmmt&1uB<1nU*^SsUr!Ar?E9;h(m6es1sVh1)3}~g* zEDc#L#W8Cwv3KaT+X@7#3GK&&daOHLaTk42k9c|MqjfDv|y{RA7`Sv`Q*tx>IxmRrkg9niyM*jq815lts~SjP%s|%rkWI z>X!FMF^x`s-j{sF+Lo7P`9xHbdmm(l#)%>IK55|b$kI=R0ngz}$;{#}hrG|331Bcy z3(aj{R8Z9R?3(q{RJ=7Azt@qKq-G7hqmvWwugvhuND+kGdzBD45rf`E+_g+1H!Lr= z5>wLl;u`^2eln1S?c-en?8PMjmNRz=d0Y)CoViQLq+0@+^L8&`Lj%@qS8AkFC91(` zRWl^S#AxWwzDgd1<*ic1jG-b=`7-0s$k2ZDWv*{DlwRk^jM&Hk-X)WJk(I2#2L|}= z>E6!%#{Q-njc!?H$ExnV(Y>7ObqVs10*Kh9CBUsQa!1=+GI`rhmQfjG_LbF9nR;Os zdY>Vfh@1^)VN>Kag(?)~863>c`rC&rShhOPh*6pN8|6<8yi5c#N zS0kH|kb^Zi3>+glVGNDqwUf=x)|Zne`utL}H=_W5n^juua^YfYX0g%2#a?1DGw4ta z`>CvT78|BVjL>5Ti01e)Lt_E1IQY(_>ncN&Z}WHS3~dvHLT97fdDGm{ZL4rkzmWA&6Z8yvXVK&Nv(4+D(A|> zWL^)1WcT(Ens>T?aI}ZAOiBA~0NLCqu9PRJfH?Qi5ymVR&MBu(OsZt%h>g2^q*5_r ziTLX;HgZXS-pJW4q*k76T0&)7-W$<{(jrM*iT?f3_VzxNST#%db1TUeERLA`%|mYG zPRpw=I5wkXNKx-@B(bUrT6=y)W2=uVm|UkNN%3kPr{M;edR|z9)uTQKfnhm7agq=(@=cMo<4QVlEF>wE;Mk} zhkllXlZ|l}%U2amGy6JB!;3*a6(d$;DY_#z62oXT&W3S4$?Kg(U?1W05(Gv|*=#I|1^3z>%c>O6D#N9BvEdv_Z5ZIE#GE5s$e>|9t z%FlriE;kQ`1NI(hpmeN=IC8_p3C0{DOqnq_lwBAXN}Vwzls{uMWckX0Ab^=;fDlvE zh+?#9vfg#FDq?veM<#@|wc|P%N=KXx)-%%*w?8{mS>2XzIIq>V14&r02O)HqU}ShF*Z1 zGEMX$hL-C?l=vC~tjE*pFG#wzQ>zm1pe zuCXQ6<&O09>FBrdvp(L&l;kS@RJslbDu`eW;KT*J2 zpebu0DQhr;vXa~mvku5g_M`?Nu>tE{jQEf*4ihpc-_w%(P9$n7>|R(^4pi2aOO}-t zH$c~I$9iB>YxpxuHo`eb)druKg%Zfo-*Itv(vsPUi?b8!*@^Y+#Bz4x8MBiXW+yJ6 zow#&%(&FsI<+GC(XD6YP*fiVV4|E&IQo3xn^XxIzO?l z&hDygUuDyZwRt>jXIzeuOfld;_WfaCJS7yHMc- zWLo1FuZg&L=1+XdHmI#YC@>Arq095q9DaQc737-*4Oy*q<2dQ@R;@ZUXz9De?{8va zeNuaF;AVE_t<2=;sRw@xFKZ6R2!((1c-N?|zlp-!34tfg8yurs4BN1#%dcQ@CO&Ur zoB)+uPq3b8jd=KvAvRDp43szl;zSzu%TA;MvvK?!2I-aYNj2`nYV{gM!aMw)hEbSF zQ4FcqL@1RBBIp_y`vZpBh*1)c;0zrG6u}2C&y)OXra-;+a{}E2TtfQm;UQ3s(K+zp zN*PkO-9VD-g~lO-QQ3iXis!OD7!4`p8@cvDfriZPFdP8tU06ejpQ4k+>oB-M8yLpd z?uWp+M>Rq)Ill6HLDCBP>=Nc1?N&re)MtY1)7HJ7_SQX#k}b0_Q>F=8<_GmVk<3Y1 zr{7GcQ@3qQHMHjZ~@{YQxQ+JP>e7HYN+u4Gx?6XgqhKm5rWqvP}CmNC1H= ztzCr{g%VRt$0K@7CpjOYXj@``Q^@=*_Lk5-X0QTmB2Jb-)^CD{Pg#PXxmJY6<5p4h=`xXF@>Vj3aFCMh0y5VobiJsrE}=_QWi^jkfZ)_|Fz$Ip*f=Hzv#`<@_UP zZz__YlsFIoI}%{00^ry?+hjZEY>(G5Zu8i()SS<}DjH@^eCEy|)^9+8>w0P%4AVoL z*(ftbW6|{_9sslUq&bZ9l^?mH%-cTuszSd;R)DOCH@NRJgz?bfX~eB%ayp@DNmZx@ z`AO9o8Wmj=Zn-}RzoD2jVj+G*q=Hy8@3u~7pMy*1t2hLZZ(nXLgw?DxZBM`*Y)X`! zw>wr$txhIQ5iLCIE4N`}-G>JsUmTU5Cccs#B0thw#iyoS<9Ar5X}L>@G#CV3IEj1% zd2|+pIIzqEqr=q z&9*ed{;J>U;QS+5MVXcdZ;6I*ts*tm4IK>-mOHi9G3(R?%LQo-{+jl1&ZR5)*T~{+ zsmYkw7buv;BMMw!Sm%iI5FHU8;eo)p5!ImgUS~@fBW_6-J*a?*$`7kTV}iptb*It{ z&#*2&#&gCyADOzf_7d-FzFpj?x59k&%h8@6`F-@#y6H#gEricU&9L;Y(V<3!xE?9Q z^(Dy!XdnSFh`IqSU$kYlnic=7W+k#7Zs|(4tTS5H&$mpsO6{Py(5pIPb)xHi)o9=P zX+QxIN-#;r^6eJ(IATr%@pqH|Z4bF54qOsahVq%idcaL5S6@iu$=9tQZ*aN#0yaOR z%s;}``w%P8Ngu=3Ae3_CZsy&S4LY}P2ZUsc#06%NwwbY1Gp<%LZS$+OFGpnHE>?(> zG7P}y^~7`Y!zBJIAo`^R=j>)UY^L!u=>eU4J|?ZR(fQOZ@ZzS)i$_vq<|kJ5`9X8$ z6KdIIG!OQkKTc@%B1XJ>H)5s-rWRs3>CVG4$QYmXMgDYf0L&LFEj1@hzno}g^>~~C z73=r`OuP&Mcpo^WKM4JF{Y9(6imzl^qk7nn;)JJtB3(PZoS9l)A%R5h6)F=g^U;}q z3nXM3jh3K9*>0o7m!-QJ635si4nFrl8oc{u^M4_EGO*n_1TZ$AGVv*~lFA5S!7?QT zF=tZBrxFJGr0APM9yw4P0Ktm%jt(lw|H!>Z?pwg;iiI>v%UxP=+w0T|r(@&v z@CR;sQnHND2}G2=`6}eno|G{o!*>DDw93bW12R2*>gZt9(d;)2vV>fzh$D{b(k`Oj&9u0@E8JV`LL+ZQqI-YK-)Z970TjDg z`vQ3DH}!7r_G~vhSNazI)yXVSqjH`gj^B8^g1)ymv!_otv%1lLsq6eAuekZS?@&+9 z2M6TB3|I917cSw(!#&c!Na1+QlR+w@XRiGw)Nje8m2uzqbL~$h<-J+*vt#c8m8xfwz$@uW&0fYb1)npIy(8IfV^>zgRxP=ZWJ$ezZ%PjN;)TR5S`G9*`qFzeCZBxy>$S>#;Ikl%^T2DEFRJ zA#@1I&zLdhZp+S;fq19_5PWl#q-OC4=5uO1NZTYmnpZfLSi3@7@XfDvyw_sH9xwf* z-6`mcosQN-|0eWHMv}`qN+10j*Zg=o#dX;p)!^;$Kb!myaHT!050Wn_75@c}=xji} zyu`!9XZn4~)#IfiiE2fQmtnHr7L@}rWkXv`eBNQR!~L^H$eC z0E$hv<3eA{*Y9S@^6eu9Q`N>M-p}+#(J4^2TG%G#wH!M;w>>Bd)*MHr$Yqd6X@ES6 zr;2Bo8k2+m#r{J~4T^$Hr`Zl)d_b?ToZ@S55HGJT)6;Vwwn(S>{A=~b2YVHwyNlzY z*Ay!nRn58OtY5SndJQS7=0w3Kj<&=bO9mk2!ojpC>)M)T?<+Ixp+@yf5chi;_N&Xr zDtnyEHI>2RVo6c=mCv1#9|uuduD!`Kq@3I;3gV?#mF!9vVtYXExX!l4(OuF0JIT^9 z=CsEZ<)6afCP>Kmf$ORJ$gr-S*cWE7Qm*LABW;fjQ?R_^({x&JVjpSB)TAe_E2YyX z&2}f#A@~&c5J^y3KFMpKObO&);42-QuSg$+D2gF_p(;auIfgRMScTXQys;b-yxMU- zW!6Rx@>Wmg%V0Ckh#?df4fH+YE;5!z*$Bxu**H7_cTON(N|zjy*Ew0W#^N4Sc(zeq zx=M$1iv0s|@t8XM*}5fSR{K znqqG7+u&~SCD_~N5=q&rs>sYfXS2CkNxmT%8r>zo5@ArEfb?Cz#eYQ1s6a=zmy^0@ z?FOp1xcwLUy{EgqXZCtebehgkT=%C5oX%G; zcuz5roro(H_&J9Hg6(GL1P#4hpzjg-ok{QEow_h1*v;q)MhPS+DvEX2!FAU$&W#;o z+2P6atOJ`mo$flg{Pc~>rg@LHsjkrm8Sc=;j;7ntxNX6=@NTacWMl<AzM#m8Js57S~NnQa)g(h=a7#6 z{aXOMjCoX0UYzZ9ozO*WVfrrauX6yDI(fc#$t6rmerKejxY-h=wkM-iSSAFsg~XWM zD!3m1HX4>bCy z@~rCGme4yCuyk@*_HlI&%Fv)$pEa)Qj;}j|xm$jE74&phVgvUf8K9}6137Cv_jr_q znQmNH*NO%+@r|x>CFlSZt+JGY zw(DUJ8P=CT)ndRdqdo>(5($#!ZBbvE1}mP@CUYi4wX$3DS(TE<^oo(>|uCIN0K0C9t<`?*y*}u#Q{x z^GH})x3~E?P@+J$&9acw3@lXmIYCmzAGh+y9sSrwuVLehK*d_Ygc50AIy)?2z{$3o zBWTakOTTcEKB@d95N2(U2XM&BaI+p##O!UW2ajpl`bx9a1T0B#IiQoh$tcZ4fC*#0 z=fiJaD)EWi(&d<0&`if^9H1aA$wPjq0y2T=JjE{yKq`mGsHA9)fMUfpV~b_RfubL%{O7x!N%ROh-hB9kMdhEuatBzIGu#@BMq~--80Sae8MT64JXP5Op4-k%v z(PBLGW%$`s+y4*u6KXKqfFH{zxq7#k>n|4?kn#1uZ=-w+^U)*J{nw~qsGfr81*PAF z{SS){KQd+Oy5;5w()G5sPEo(3niY4T*S_yU`b9iy)$Nej-c9p`6-?DZyp;$uJZY9`- z?8)W(k+CTj*YPBjlDw~=@j;`>?o}@yWQ8Cus9l%+<8~bt{s&7@7N?}HB zao~zsCU)5+Goe^icEn1s3)$mVth7*3>G+lA+EwSqu{6D+G5gkGq?lZ6#=dntDM>Cv zW6Aru?2?m98ARa-GXsq}%gDnFk8369MkiQj2cAUgfduMFyJ-9)iWn(+mFqNSLF^nH zl>tGr4R>-CcE8c|0FNJzhh>En%n@2rqB%na3V*U7isrf9Lpk?$QW+vS=eeYOQJd1r z8(XN-%$wPXl15m0l~{Akg!K4ywo`OrCaE@%xZl+^DhLg#*> zRPJ_da+Gpur7e@Al20p?wzu9)j*mtvQ<(8vwWMs4vi!_s_H<oFxDur8kxEDL{KkV@6D9ezn_;Q!7;-No~v=HVvb4SQ}Ug zrDlrmx0%YtQ!6D`&LV0pY8GXfLXH7lCYP95rnbYDE^>*5+H4skpIAgtu3=Ga&ev;Z zRQEJrzm-vrtn{?mmlF4o6x`xOfefroPU>OrynSn47DEY_-FjE}M*w)Y zz@2A=@&x)2o!YXSL%R9Xw+BE=Bi@!R35gFIET8`guj`5D-JmH3Rxgsg8|yrIBKyAW z^&Gc-f^;x*bQZ{qd|H`Mi&jqizT zzF(~Q{7xB0@V0Ijcs_+BuB9`g&o(tr>7Ht(+G|&MPbDrIGWC zh5NMy_sW3#)ynzB?2+Bs*Jc*zGtIN`HQ4uOUPf;`G0f-lcjzBuZIu%S zI`=>B90Fh8-rdIFFBGF`&cx_xnNFt*Fc(uVLl^8ov-gteo`@U&O>g_zQfKMeEz2Ar_ngVcWX}?ZM76Ji+p)4hLH@_c5ok%P2so!r+RL% zQxCq6{Xy#7i0F0#a)(Q9H`oBNjhjJd`X(>Z9H`B=!-m?#ny=Kt+ypw>@syFv=9``N zre2)KxfQ<+Ep^xN-_{xatNF|x(xZ1Q@$9|XXzyt}pS|O=z4HPC`79a8XURZ5O9mqG z0uy0>c#3g+fAdHCyUjelE9SvIc(?zx#nR0C@Lxcp7x5Ua9d2145}u`5`}UcaX7Kfd zES|Pj`q>*z$@pC5nTLrk`z$DuELuzocNV97Lc$p*$QQTfqEXf}H`rdeb=}a(h1vk~ zEBA1cO~mdY9b=k;r!nF8vcs(g6E(FO)3#0TCneN*VlmcjHE`Ywwk_N2y>MIj+=`#3 zRxPmC2H0y8Z0+IUgklhZ+;5d=zA}n5SIsgnW&pn8fQoUOO*I?w;Xqn~ zxHw#|3}U3E2LUR*3Z=EKAJy;$_C-(|`ALTI1fw#vkzQlm6 zw)N}}?d8s$e6_dBeF_-TtdbqIWVKx;Wx8!2&P{``8#uQNpYYUsuwN)qGdqb1#L6Cyq(AFsh|)0p|(EAxDoU>Qo`mE7-o)fN`n2)n%ebtxM_GWnjA- z%Al+mpL>|3Yd>uT-oX`c?=FAb*NTK61A2j(lJha~{4zmz1^kJoPe0Wg&KN&OFvMJs z9|pY*0vlj)dSjnl2V04M14AjEEOx0#j26l2B-pz0mU_XZ4_KDir5_Gj5f0HubW$@Tg*u5_*M1?m4FCPUcf~vE&VCXs3AW$m2{! zW}K-~I5)dWVl?%;scp}Yv+1+etc5A94^7%>hz<&p=BqVW7x;>`!tD*eaO0ce*z*P1 zay!FQAX3ScU$~4r(b+N6XaI(MhA&NrI44M5=sAZET`wMr@LgUY9W`By``$fp-0nAS zo<-eE@wILo87VEpp4}g3@h0l3)e}^eLj13oOp{qm7Ut0UB`XZt!3A3TrYfyF29C+w1w#TSq0?? z8th{<2H7)5d_&q@f0mAguwI4BD}ijp@<|nRsYBU(Bn;K+5xxT-BR8Xa2sI*uOc=k? z+e!XwSG?xL=a8cNA#C9ne)k*h3Bb!ZX~up2!+7J%6M%;&sN|Nq7@iuY$6es)K#Tl6 z#Aj-$mWd7DS3B|{(1%u&?B|cX$O@`FVW$e%^gTrx(=53ayUWD8&plU9HK#OrV<}^- z;)+FKb%jgB)aujd`h~oHMsmj~7~9 z!cHG~Fk7c=V!&}8jLGi0!HMZljn@(N1rHWA*KWe>s&*TXlbUcc(yRH3-=d7NAR=@i zGwq^zx-&uNY}k@TG%rifCg`&bHBv5{5J`T|*k2jj$k-sDhn`Hn`ov)26f+$oq5jFj zjEypOlQG}`Z!>lZX&Kwq)QnFb?!WVu))_fRa8Av*mA?zXl>EogIf7Idp9tgkctqa} zvAOtMm>!X6pn7rBefo6t^yx+>&a}d%AAhbwp#0?;Fa|P;r)C^+yl;o>f`0tYE5I%v zQQuFo?=HLMZWKmno%fFW|DxX?>G#bTasA10b+O?eUG_VDUDFqi-=ElQO1s6h-zn9F zLF0bgFzqjTOZz7!^dKSQ;oITsUia?(8CnEm~@Vac5Gs8YK2AWKB@4}=~>Xn!gZ1r27G%=EZx`gsI z^-ePNo88vC{>UfK*&*zPfb+Ia4*tjmgZCZ3wF5}+2*0^*7FTHMeS+^)SagrP5VKQ? zH?V;}!{{>h2Ei05OtAa+)U=dFMff$GB;I?=xg0d0o)!9zm-9LQ+rusLS816h9ZY-u!EVlq(_KBZLsE=WBVM4^d<0sUyx+{EXM>GB6?JTykM z%NXBTSa7i2d)4y~-a&cq52|{9uuw-f(W8E(Aj-Qz>b4D|)B@n!CLxu;WB=G4P_Uu% z*yeBbCiMxM)NkRxJNWO$ZOL>|2AHLK+~;hl>heZqFybU(Iu`wRL54Nm;T0PG&RPKl z@UnKlt7!MTV!Kn0(D|$?drY&@?6QPUe8~zewjrUD8(A*b0pWjQboF55e;)_O`B?=t z6AeU{#oQA>0kW?lk+AfcuX?OUnGLG@oR(v7??;)PSBK--05LH?>5oZ`@8()T5_p*h zzRU)3@|70~8kJMtjLOMk%ji0uT2JvG&O%Y@yYm_-)=v1>KAvENQrvQAoOwIa)<(oQ zZ|{3SMzLid9_Yt~{IMOQ2cG@XvgC|(nDL^!kti_;#gDyI{P?I+B-Z1YU1wf#ve=%L zDh845WZpH%jclL(_Sqr*y=V`!b*GQlOFJ3s<7Lu5{#`xy4)O2Wxwi+>ARjo+635}S zb5!3v*gZG`#?^P-meUdCJED9?l<$<4w~BXUtcJS>Po(Pm_mk-2OW*hFNO z@PlV$3VNXk6H*)&XF{ZuJwN^CyjcD9#jme^S^f2;>&o^ycNU!#s9a}(EDc*Y?&4+v zt~IGB0MLzm0jW=^E`p`p>c_4@xk9!2z&IDYYzAi12p454F@a3gDYIr#_4eIUvQSayqR zPq{jmB(MRTDk=mpaR3G(84s^)3pkOXn9dw6#?40}=w8 z`Mw=EAAI=gxih=N??}hJVEdSWY^qIf_)Sb82Wd8WzdbsgPy$K;Fc!6It+oI#t|IoVYf#XFveH9bgb8P9;iA|n=z5s6Q^^oCl25^ z*hQ^|Vbl}QHje)yDf9A<`3{`&R9#2>R5EeZ5wU%0o)%7VGuigLSB_fcAaI@_X5a}a zI@H8ckT`YOq~wjR2IV=McsmF637;?gY{?n%R+xaORFIC^q3vodJJFpT^N=;TcUcc-mXV|CkH+L3K_?qJ{J8c*1<4)}c!Zd0`3-ho(6 zFWQEIu=;>RfcqWC@3YL(inRmU_i{JsZNRoFE;RSCjvmPNWQ2^{-$C8bFiEcw)Si#f zN#R*>8MZYbT}OUD+ebfn<0x|>ryUs1tUqS@+04fb#!w+}5d+T)BPYWs4iZ~nU_*aa z65o0rU88_xPZo7shfu7%6~$tQs+eRBftLj8UVBi%us&s@UDx-#&)%uo6#>b~g6k??Q%(N53!L-*XvnEA#FsG7sTx zZ&?mp;H$~c2xfz}GEu$6bR1B$igdlCJuL}@o-B$0o!x_j!(5vw{TNz)D8!?EjO6t&A2amlw;&x4W`TSj43hos^tb)f#%qcUI zHj&6ml2~bldTwmJ4MBEr*)F*yt@+VLSZ;>4kfjySYz1Bkrl2I14I&V7*A>CnFK&UO z90rNFyTiA>q2&B`ZoSJ-_kxvUsx)PFw2|HS0L~%bgEv6{|2})>4nsP!#Fje! zL5Bu#Yl(diXc_RK0n$AC9-KcPM9>5L5TOKx2~j0Z3@{zSsj;OOA7C7CT?GC0tRKjAK5#% zCj7RHACrXwY9inB^dtNr&Ejzw^#{SBpK_nc>y7~W62N{N+3~;vsS;uW=xek9P(N~8 zDv@u?=)EW$6x4eB#Cf21;sXz38G1gar2~52f)@#=F5Bi7rb;t><96&#%$)~s$ zA`s7=JY;gR+Q3Kx<+LS-%LEscsRF>@O>q(rLm0b#?>EC`QpOzt-W6q55bW*+!-JoB zj)$HR{NAkt^L;05Y!GaUeImm$&jWdHAEZ{PYepqkI1J)3b-xKmV!2Ix{BYEPHSG@u z!Jw0p$lDS9SaPK>g)MCraR|44UxS?6zCTE0{|Z~_S6h}pN>SaUj(_@;7Rq$;#VsVx zQ6zm`VOHMP)gS0ij$6E>!Qhe`xNtz_;2YBCI>e%u!a?kPu?pZ76M4_BTHP|*35Cjn zJQUBxl~C$XY@9AEN+Sv}k2t4jbw>|Ao@i_C*+)Ntw^id0MWoe^ug!tbvW*wysEun1 zG_vI<2(fli%r(y~1y^5_60e^wJFTm&gEQmPnMh7ck-S%jWe)YeEU=36z8J1bf}37= zk?Ws&@3kLK6iDezh*lV?Gja4bfCVa?+d8*+*T8m+ZDhivjcxgUvY8dV3!fI;{ISy# zzryHqRJ zJQUkai8()~4!6q&1i()yu;od7q^^{mA)0D%!@TG+wjKgKd&ZP#^k@Ad=!X&CYxTx@ zfbZK#vC40y`6ky6l>~M`S6L<=NLN^linS7n1DZ{uFi&bLC#N0X$Eb-iUz1)3xRi7I zKRcBhFJBVIyq+ot$s`MNdikwkZO)ALV7)oNxz4ODdQWZ9p8^LpB@;XfPsLD+A(&_> z{&6@r(KR1p#IwD;OLM341Snhl^r@=+)Mfd)nZR=Dws*AON8w5HLUJWs&)iJd@@5Kb z;llET&C~b7(a;}3ZaIJ1xC9Z%WG|$prD+tJQ0`LOHSO<|%(AUIw(eYd+h_87rFm|W z5g>a%h%fvB$90?M2a+!NB%>2O5&KJ2bE2ymdM9Tmx|SBV#57I~QL3*LX}gdiWQ_+8 zd><(lV@07beUAp#E(q;ndJYo!N1dqdir`dS834ITG4-Xg&FGHpc9Ek&>+VK7k$gL`F!^CzNPxo%ph1OiwuxB_Jj>Hu4aOY@5IX*b&92qaB+R2MD&Rg-0=)CyKkK7 zV&7Ew`B@D_0T*yixS2lC+wtfsAdk`FTwBOe62gQe>Twplwes;gB;!}D`J#1LSx_(D zsSUF#w8LyJ-a=u87(uLgnlpzkvyU@y5-}Lp5W}bA3q-~7c97%kXWpLTcstpf{S5xq z9Pbdb&vvqN_7N{3&ki#++@v2oZ+`@)_OXI8J}SyMRLpTt1ugt<8q7kdngP4mvZy9=&%(Q2OBKy|B`r?lClX}-U zg7X_!M5rE$WRheceV9uhiu5wGLb6sslftr0x?;^`ayO*8Of;g32e0c-UwMI(`=r z+1>K(EZcRY!<*S4vPst{uNUGUwr>l5+Jg**ZrfDiyUYIYZVQ$Yf4pfveR^vfv^dRI zzx?vcYV#$lzeGg*hCVNS9mrN*?Ipj=TS1*F@3&ZyYur7G zYXI~St}ZfxnkN?G;LVT=F_9Y1V{%ZU9$~idg?9(in>gZt$=f%+okA_RzgM(tLhafw zx%AjKX@9@s(qmuI`F@^iZ%d2_;Mjl4_>q)XD{n*oh0=IUvH*1P0BTH(o>6t-a<7P0 zgn+fo8}77)2HRJ=9XZQMnX&(w+7CuH5j_2x`*1_jJ;^L5GbkkrC?@5tJq5)z<7BMy zF(4_sEu`r?Z7FhR23zzdRi5)t>xK7PsG{$CXk5}~cfy^d=Tu^N*SdE3CPgF~EBWUl*}I)%u$)nZ=N#qNX?DqpIb z;+_Q<&@GlmV88o)4CF2Cd#;h;Vb91`d5`!LbWWi+s%oo4mChH+Z#)SXO@t`%$iK1E z@enO#1g;W=p+{p8`#tBMvJRK2{@?LM&SepAmwH<|dT^ewV0jJx@FJwig(Slhm|9aJ zA1zl1CydcWkb@av8bb7lM?hu%fY*@&H1f;9g{HE)5C_1bK!90k6_{ZGlq1D#jSVZ< zNCLkUqs*is$hw_oMgH!|W>dnfR>Q0!%m~#brL|Fx4N~3%%GX`ELQnOiZ74;H*|{N? zu_{LM#v7M*c~ROZ=a!}m3Na;Bm0Ee${FT;{%gq%SRYQ-|&{nm?&MbhJG^UV`3oysk z_A`TlASdPe(S1X*8-;kCNXkMBF#rB@GTVkFSGt3z{_med5oF6b#ZRVz+^M>xH_Pc} z5u-Vk)gS0Bx_wXx$qbuZAxiT>{Q_;Ckg=VrpGGP-^ggw}nX*OU<@AS@Bg^JeESSAG z8C_X0lmaj*9JM2kU;c#DA?9-7J%t?eQ|5BHQ00nGnM+Mjnfxn|H^bsQ`!3zk&%JuMw5`sd7)yDl^J-zDz)K7ULjtYJO=Fu?$Ts zL_9b;(Vc{FlL7>5Sd7pG5sF8ox>#JY0zpr`Wxp+uUTdcq2Aqya`T>Zcefd2^iO{*5 zE0*0Uv24i2pF1&VV&ZwPpFFWFTt(cSVp=`Sg5fc@yLdr|QoCTrX95-LPwsRG7?cT3 z-=;3w)M8O0sg0s(EuQPk@;OGdQ!UG-CXyfr=l#zS2*Hv7f*v$U4*tVK#ZaRd10}8F zteo^w;8i#G;i0OjWjWMLR6C4}tASAroY#QRF@Nt_IJzT|uXTG-qk46|^Sf=)!JdOb9R#xwH#OJ!RmDyt0R#qae zLET${eXemx?`Cavsc`%LHXgIT#$5=C%qoRU^iZ}DcpP0oh z8%aW7Yy?I}=D~^193x{lfE3R+P|bpA%x{%FF4}~Wr!LkrdvGiq3y%)p=wv(i)>1M* z3!!M{QK(jIWrF?T;>eH<;o+9o3VHAW89_#Xg>CDJW!qhv|0kyMFNwq4&?JPJ<`ST} zu>sUhW~9pP>a-R2ToeeRGI zH@;DupeyHRP4_va?C!4uVkOmB;UIDG7DGwu)Li^Yoso-IStT;@99z-h7P=Cq2T68? zG&i~myGvx_Vy1{F*(6OcqA(0f>rE`WoC*tjgO$7YyrP2AG*AT~ zW`0Rd{aZTmeM5^`nD4jf81ijUzW_d9v)QLl-v-)7K;=3Gnlp+nF&h=TaNTKPH+4!I zEcRE4saQ=8fF5KB#kj7H&BDFYn~Pn8Ab#{1hBlqedikjj6o1y z2V6OTyN{jX@_o=s%fsXc+{(n>+8BvN({g+tj}w1v1US9ZJGXez5Jh$2b~#(4&G}5 zk_$1>dG+#LS&&$Hu&Kbr?kXb7@*1pQw}myxO`DJog^^R9UURo*2wAvD%M~&2;Sk>Z zF2`@+Hm~%GBgFTlg8tn&+ zRoc+dS7ud}&FSOw*#%v<1)xWiE6K*zgN_EsW8a}3wdk4UMtgAKu-xom7v$}^}IN$#*NY3NLN3nQdZUT_02%hJa%_omV%bnK!M9NQuj zU^wQjr^Qy2X=>inBySk~+U3>Qk)`sMkwe-Lx`#T{qSz5%IESRmm~f|S1XvG;eqVTD zLw?8Iu9;aPx>?aTw6TQv2)1eq*rca_vQes=U%VwXJ@D9?)tt*Kh6%$TjD1zkA~ZVt(2RgqRH?DDsl|t zwcgRm3ABKV*(kiMIxTJ4E?VX-(72My0jaKkqBsUk&A)quR=3KB z17A8#<*Qh~XRa~w8k&~--9eW){8c)+D7Ad&^V05uFJ{Z?Y}FDYO}?Wol;_#T8(Q2N zujjB7@x-WBL%kMpdgCafcWx@lWcy~g+s&EYd z$|Tr3%EwpdC<8e=|AtWvquSB?w;Q!MsfEbUP%q%~_+i0i7{RW=8)-jHHrjXs%~mbk z|M#@;6y(7^wB_w>M)l2TEf4FV+IspMvbobYp4fUI=5QLP0F~#!n;<})^oieK9cExk)2j6H;XRb!>BEiRhYd^d& z7l}RbvsUK6c}f1vmG&W4dDws$*+8=D_xOf!(RVW%^qE|viSIikO#UD8J}bjNwLy|LGUf3~pnqnUw{VL$#{ z9`I3(MHawVTw+*+SxqV+uPXRI>sM|yW1z**c#>U{Bkg+xBLE$ zA7-_;SI!a30``K&Xpw=09=x>z&Xs{SNPT-`haNgKlBmsDfLxQyJU@eazmGwr1S&+Z z8lA_|nh)omcuYZ~61=>o$O_W0%;?q_X{{Ns&e(K{repR*$FY(YS?@yY_(k45DzGYs zT*KAmQxY5nh0}8Kb$RM3SHEYC^M?njdSWCt&$Wd=-Aaz)8)ucR9H5!M>AKrIO)lTz zD3@jPHHi6e>^gm-tlK9odO>QW+_oD0RH((v33}x_qCtd2Ach^pNphzlRUR<(3(nuL z@<%3kPaYXZcXU9?`}D3t5yB3-vos{41;i6er%<>FVt2w+l)u~IwxEm8X}*dD=JRg; zd|Gq9O6O7iy#{3((#a7Ew9^)69}flVKdGsx2oSNOYH8A~`BAUd!v{>H7_ALZGm61W zum$@#d~OSVi7-NZYUS%A;1T$;85qhW(AH@a>&P!d!Ae>Z@J%0U4~#ArZ>Gb zvKH9B+a6j=Xe1X`8qrgGJ4-Aq%$t;GLDtc?b->j~tw~;Wg1I(20z_;r$f7RMtGfnv zqcOcRoo(JhKhZ}mx{Aj?cWw)l8<^O@B(*X94hvlGS*JoI!mB$w9k+Bo)muUPw9r_` zWD9Fsust@&Fi>-WwJo=GTB-{=tyBfsXjiwm3Z;m9b*r;+bhPmmdYNNSWw6MvM!01h zqkG{HIMwMs?ON}4cMdyWJEYBKr*v=owG#O7XnXH;_hjdA_iJZk_wd7pDyL&J-IDoK zC5nyRo%j2A28Tl9XykXlZ46*#(xW74$%{?5!h5UIM+cufyW9KkPd>Qlw6O|oXK&;E zcIU(P&ifB1F8OY(06hK(y{A3=7;k=O!$IW$6{fSHsP1DF&Pw~Qd%)yEsvIk`8%(XO zN^qkys8E>+hJB$YNwa`>S5WxT=3tXjaxSc7v=XbPd<#^ba!h@#t9g-r&i6KuAEz#R zuRhWUWJ*(hckzZ*WWEjZndO2eO1m9X+I%0BNU9b3!L6f>&sO1sq^z*I1^z4Y8tuQL zH+vcU`|O$9Lz9D9Dz!rEN>y6Ug)m0SwFr$joLKOkJ?Zi4rmL7!W zC5pqhN4{I~9g_bp1_gkm{q2pT?c;E#P(26ON$os%;RVq{$BSBOCEvW^KMb`giDtsH1 zli$qtFGk;H`^&0RnZP`wy#h4``Uaa*}g+C9o2`~sT- za=j`)5ma=j619{av{+Ex!v)*7h{zHIiwP@(Xdx+O7%m{Cd=D0qQn-a3cawKo&w2Af zt+t&6lU{ltXO#!*wXHcvYs*aN$4=I3TML}656aHgch=duZ21cM$}r2nG7>@)#bcz#EpzN-mMd*TC=9|J$t|YU3&3RC=5YtBgUkIgvZd z-U2VT%M31z3W^#Ot|c+dR@cq57N(OjsN^J@I~!V1McKK6&6S-52~(Lus*;%L%_O}G zGflU0ft5Eh>9$k3ek26k!EvWUI?2w~_NSABgWcm!hr2s2rc>A+w5cY44-RTIH^*rf z5Bc{}d_m!Qm)LzT$oz27!X{2#cZ!PlE}Z&%Ay9pAd<#@EG=fz|1dxBZrUA;sP@~`J zVxde#X(~po&g2o)%SF;e-?4P#uL2A5$2?T(kF4IwM=!LhV}Us98dZrxr@3@T*_nJA zc=zOiY>BV^r71g%WfFJpJY}a{nSzd-r>vWhCyk4gy&ur84-xD3xl*MYr_L{p<#$&g zcfVgfLiPT3AmT`W4!qT6f;!w`e&F5jAM9_pR+{YS;AG=u8=pTO?CySTHQC|DeruJT z9Gq@`=!ncU@rhY4#BTzpl$TbDDDrB`I=E-bdvL%ae|=-jg(;+ZH4?nnFKqM*52da?|d9zuikiR0#l#l@ZG`3@hE@+ZJIFT=Os{334K~{--6qt zVk$3v=trvP$d4?Dw41_3S;Ws z?{2?4X)OVBjc;~?%WR3A9*WP?(GojCc}9F6p`5kE-X5Hs9PEj-t@tKd5{z~jkJI4o zILk0HFvt5LtaFNIdplcOyW5yR3qc@;PgoU>#pcA`cr=5Bnw zvvWH|5&;muAa4rxoWuiesjgAP(IGFg7ejKd&)-B~o|}ijwdsv#L7a}f%hG(Y?e7KA z*xM_G*u##0z6yeY*DnQtwL%T(l;)n`TIUmUT@65eoK)9O6^yF$sr;}cpL*X7MkL?B zC=;UN1pr~hZi`@=Lnz}tA>2n1dVCXL;yDY&*Wl^*x#A_B!UTo%kkOXSaG?p+IJ&r@ z50;8lum}zjwGeX0OJ#Jj2#y=1m!%RKV)rAT+zYp!G^a&OC_Th+wvQpf+!DO7lbPdF zHoHa*4c7HXctn7oC6)2$-Lx5P@CCmV0rOm%f@ohoaix(LA3t}q&|uC|85?*Un(=5M z3YdlB5rkA8e6@-W7A(IYEn>hJUg#uNTemZhyh>|ah{7IARw$PdS@A%x_cBVZqOvK; z2T~l)pZ3%)T_0VA2r7hNe=r9;yMnVP7LY=I4m2++^#s^S>=@FPI~^3p7LS(m*QeSX z+!+#9Hm#Vx`^qx<*=r@pLbJP2`?wl7_0b_UarJvsEafKn=4j=FQUf42+%rYesZdSa zTVijnu7*HS5P21xYK9GoHF&yqE01qpg(x_#j_s_~9-jue9k1lTIu&`D9hbaRSZ{9! zyzv1D!{ZBkTp^E~{%cX&(SmP5(3Qe87o^vmZOJ|LAxUiBytSTeuSgZLDjtJ^2!eGEcMDx z?d>pqhg!(MiQK18)dvN{h~BISRls`m%=;X)qTj?fX0AYr%Tf)K5=?5qq#P!ChJxqGzf5e0ANZp&V^%e#K?8pqpM)tLVNIwJT+~N@^JT z--2WRQY~Uzr$Wx)OkM=cpB&ux_yTis$3#{}jk)sqGOl^x*Xy5avh2+605Ee?UZ+ec zRjQJ*QK$w8{6xu#ctlxHyGX83IP^U{n2fB4YoD#PJV%qW0%-k^DGN z`(LhR**N&SEb;s&6;~gQtI%sfaTBH4Q7l^w?jVl8ZDb{zZ3(G5 zGdQi+T$#^oHD8?tu4p&^023novvc-v#M=bDpxJXIPibM}# z*hc|>MQ;Tki@j~>u)%TLektk17L|y5gn<{Y`0Y|zq?}LKnie*2OGFSmA|b5ICj({G zGI!0X9&z27p~OM+N#pAlP3L30x8M?wiCT9rFFdsi(o}&t<2)4E@}ElGXcT^K4yn7C zG?sYiYNyaH-r(+H-R@R&yIiV7hTP>VGoC+RzDY}b-fZUppEr*7clO`6Y6rckn$@rHGVjx!yvlunhr$U>N&q6?FLBRh# zdU^Z**@fwstT;(e^Vci-Ub7GCwuZe-oty~q!n%Ag&gsXnk-{=5r=QuTWw{sS z?kR{0%yQpVmdlG)-C$JJFD4SoitV@JuxNK?-uXD+>;k;e?#fG-l4CkL1$fe&Rvqh< zqD0!>e-56%YAl!Cvn^*W%B;$#I&em5BXlx-2G$F7x!!21CtT`XLjBj5xeLnWz@1u0 zQ>i8?lXO0fdoA8^3f_zd<6-0kD5F4Lj@PYZMae}-aD*3Y zN32zMpCqzXR@nsJGp9Y>Bu-OxXJ)gZZCtv=HqU7?Z!n)IalX~sp-0G6>1;(uT2yq1 zgNP}LCCi*tGT&zOm+|#;WzX=u`Pvj9X)afnv*qMDUV@^RtPk9Ru57DN#bBydmxF~0 z$!C4DdG)$uHz`}Tx{%N#QETr3DEE1R70dQ~CVRkneF*GYvUp_GaS>-3h{@HpRQDP; z@1H5iKzobQi(x^~1bQTK`CzPtfE(9Zsaif2@=O8tn=$L=SaE^wdqF+9Q4m2|Q;dqICpfM*u&8 z{6Qd(ge@%`ii9z3+d3e4>2rU1b){(^6ucEDc^{`{-X9IC2HrWr6TUF{>uV9o z77mKWQBDK}L|@#30mI@|9{PIeC<}_kisNl!dAGNtUL}g66$ehCwe4ywMH7+25h-s~ z<=SS6#(rB+$$t)(i;bB)4=na=HyCz>(o(lGOYuR~;-l_h{<1$mzB!7JrYQ49R~x4k z2Up@K5KT$p+uwx3*4RDdJ%%BS7K$mYx0(1x2ENxkdof%^@-~K2c4yv5<_Ud)QIuvv z#WCdNb9P7Nq$#cT45UsD{Ul%Ct(!w_c9_>atGjeN{%AIW-A1w>V8 z{0ZGy`RV;wc}z#hlJj5fhQ*zKQa|#Yz(ZekH@L;=PwB_co{*KC79Isl}#E>-0`8&!x%&QJf*+gxz$jq??i750IDO->=qPlQb;_CU6`;Qt!|v(G4X4Jf;bv`W2L; zQ}Ok61?A|3>j2X43Dme8JxiBU*_xd6*kFlU(HwIt)dv?zqg6d%%eM)E$dbjmAyc;j8RQg(E>A?T0|8gQ6&~pMfv3+Yff<%|9^?wl(-A?`Y2AZ z$dvvY_=K#MxWxYlq|?G6|A+aQ953WzC1)baQ5y1Gx!dOjhIpIPpxb8>E$CY3mc@=O zZFvi25yNu*C5t_a7$B)VL!kFrTruhkvuksn=5uSkbjquJ46m-Lxsp{|{CL{&dy;^R zGoD<=BlKh^!pa884iYCf>@U z_uzaAjO$(;u3P$;Ee_c#uRFuIjD9RYI4kKA>|`==l;D^t6F`1bz? zI`@;>Qqs$RZP;>zQ+&>$lb+%pVs3C$q*+)*Q7m3kB=sB zEzuSbiphS=XiHf;EHaFKVIvW-mdlzeQgb8!@PG`wRAE?{4OVEIxNYE)MqWZvj|2)_ z*qGN&)m~`UC9efSqu_OMd$WYsIlEi4Wfm141?n&$BL5)#A&M&Kk_v0Y^ax@S$3gf= z;;_|b74-nh_S_X|Z3$(=a`O2=4~zC#Qn4a1GP4OM4u#4KMai!^89=`)Y9 zGaF^i3ngr;4;W@OUp0K<0;(YnfCQUj^SyKH;<%j&Gr_+|C4FbQlC7c0Y8}# z^Xim}mdv0jO(%O*e74B_b)jP_6yk*w9!7-K(~>$QP ztxRlArwo0v1QU*+_0PZm{cnG}_LEyU!Pc&W?rQD&^tw%nsD~N)VdS{AdrbHn_wbzzwxuCI-0_a~jHECbPYR!71=2BhLf3nNO@8eLK?Gl}kQF*9< zx-k_Vwl-4Bt(I6cVR{IeipKN)vnVR+@r^%HDP1@#YiCQswQ_t+w#$%=9@mb^KJ9+W zGo6Y!NLX*HR+m7vA;?*^i$KR$33?cU1u}sGdo?6Qj9{U?1xQC}+kMi?ZFHTLCd2>1 zp9bn1dA~2TXR&^e8v^c8%vG^4RY-3#x%A}>P+fpZ3E*XW%IuV9V-oU=8zwEXy5 zmu#?A3I?%?@T;zJ@pi&ne$f|A-S66-&!jeW7^GJmGH_1%EOYZd69@uUd<+Myn%jP{M5LTH)mlN?h)pCrN?lrHAx%8}>1 zz~Rg-tK%QtGXC9K8b@f08(xM%Z;A0RKxylMTWliV>_-kdGpdU$S2ISdJvQ^p>gH#j z1!Z+RVJd0wGW}!hb8k-jUB~K-CIS|)NKBio{LG$!^Za1t^F{FVNXG*-syD{nY(N>O zfEmokcXhZAViTXDUVI>0fR~jMM*<;){{TRIX0nODi8C@IfqcxH3CBR9-LSIS{5q3e z(ksj=sMnoX1)m3tuY$A-o3baa7PytQ7g#*E$djAWc`5gI2JF|KYxUH^a%IU9FXIAL zI}y>L&{Y!#35PM>^V4q*MsC-66osQAPnFw^yWfJI^Q2K)Qs>e$4xhzsv+3)O?=@KL z;gc5MYr-!JP0FWC!N^JLN85+H8=Kp#yZ3 z)0i_>&Dm44{m1FXF6`}dXND-?H9MFph^)f;n z;m9aOJ(6JjHuO?jSMaDn`F2=ki@Dr;?O`;<%Tlqa(EjQzZNt!XGjxp%JT<8&S#!yF zStVK+l(jIho^hDrKbn%Inu)7kV0*)~GUv5wRUDvhl2FEb^NRKA*p*cvtK|~4a+I2; zf%cn-Ru?3=;|yFU&Q900GxSyk@;tqS@irsLEPxKF;O%&t0s+e?#*!*BFW1<1Y2%F! zmyEy^ZyKQ?N>b!K5S9yqnGxarIQ6(w5DNoT6sD>1kW$p7Ob=iPe^!0srcw0EvilLW zhA@4T16ZGK8)e27sUFEU3Kn>n?)quA&5v9Xr#6Ggo;9T*geY8M1;KO9f^&IvlhzMS zY5mYJnUiVEAf}nf0l5I#_&9FP^i8rD(kGaEk92VaHOV%k&*Q`^X>s}{X{XR?`+2%( zdwPz~Mtw_vLoCkEFNTr@B1X43lpt^W)+Q)B!pezPQ#Z>%bb`W)!Bb-*?K-0{E?Tl0 zbq-<}q7xNGH1KMNMR8oyl&YC=6`gvf6mG#Y&*XO}Ha-^1(c+*Go z3!F39vU0sIh%3T_;UuSF$&mn_M2;+VB?MC|Fj)vh|+uQ&>ky1-Vm%z3t4% zY|8!K-o`~ncJo7Hc+{cYL1j24ofYgQ57agF7ZM2# zGwjfAe&}_LiB|wOD&Q%(!WKF{Qxvo&Gg6$g(`T7p2bI5ISM{PaVdgm-X) z02U#S_g4NVSdJ8;Lgq$$;VAW93V%5Cl&L(xZua?{ zU%}903r-7HV{!g!EDu^QS@Gg>D6J@Aa03BZZ#3Ke|zILjlp_p5m3 z1zKFVK$8Of$WKst@OCgxmBSzp!6fvw7bB8LMt4S&zjE@)_m?SL|JWdR2kCNos*YIL6XaHbbr-3CkLXN zcL5C-LG7BNjnxa{tZ^<^(qj;>&PUw*A;fF*5wHFb;urG~ul*3>m-7+7cno5EU??_W zfqB7F+&i`86;0*C^{mP2uUY*StG{6N)${g3$hfOviLJ|9KshI2#3c_{@7z5snUT2c z2R_ah>zS_79P3<`=p- z0qgMy?rGM7EsH)rqY4VY$T2JMAt-1>2bp1QG)plc4q+mP>mCIBg`bAp$?tJmW*NbQ zR%qpnWWpIR;q1-Ky_jSnb_63vv605QZs9>*i-V=S8N)^ z`iqpF(_dNCSjfcbnrlp9sUi8LgSollj+B}y!3?2xuEvn>!O6T?&Z!P(NNDAt6$6~i z-<2cSl~a64ZuB@Rj6sU>o~b}%=r-YgF@;odc@>mO>WO!?I&Q9F3rzw@$ujRMoRwbu zIMt>{L{}z>fgr7omRP0jk+z>GH3zB?Y~?vUZyfb#$=N=IE?`<^%gb|AbjB)}+f_PS z#$H8nwQdHmZU*MM8OU{0+UyFVADpw<*?LWo!HJMl#Gu9Ya4&#F`wkbwp4Jgqd2al& z$UvIRU~oQnK>w8<&Z+yS_y6lc{a5^Lk>1DNOa$#}nkj5BKO}Kls-Pc`J`HWrPn7T; zOJ|Km>8zY7nmaKoh=F-FHm4K0+)4fo$=1R7QI>iL@glAX@h(NmDP@*}ok{&A)q zXhgseqc>SQ0zMe9 z_P2LCM;lu^r^l^qYP_s4xrBXFAfyIU;SXX%{UxivM5Vu6;}!XRf1IYFA8p3Lge&Y=*ZEo=j z!5my0hDwSNF3C}&Yv*xYdfCvPSyOz@_2Xp&$Wh$TihCgp=R+BO5*|VBzr)cN|!08vh?zM7ms+u0k zrvHtGa(vBw&jYv`RcN3Xd-ydmz}Lj&HRtv7nZ`?9F2S)n564Oc4r8>Rc{NA2=$XXp z;`mBnJ(B>t3bd^ArfQ9twLmDz$A&LkzD7g+OJEk_$B?B6waf<}+tYLpJ&;loJOcFDt) z*-UvD;;S}Z0J&s+6<7p^6x1PB9$s|vbY>M|W+x>HRPF>hzF-X?kd;&DgEd4TK}y=o zk4WR3vl9M(Q1CyKo{0UqwP%8b&8(+cT~BjPJ*$tYXSKSX)j9R7J*J+u>U!4Z)brvo z^}MLA=f#|QUW$6myFwk)s0fsw}m>c*)fBDqMYl_uKRzG^g{ z*@a&;8tv>XSzbH$2E0TH3nvy>5fMuF2=J^~3WC2C$f^RtlCi69AFN8-0k5$B^5wJc za((qB3uFZ%sVS2HVf_~YHI?>~IBNZ%9nE}vdWEV_d}f*lBjH5B1PIfXW^$w|51soI z4+G8mD~3OyY!Hnpo)f<5=9{0`El~+?Y3bENZ76JO^9`l{)H=R=4Y?tuBAqRI#ctBh zVBF5?7k>9!pA?nSI$~}0^{>C6-E;ji=C5M666e*+Uw(b@iq#v9wU^o~9W(zCIIkKk zG(+D!5A6^&^(F&qgBda+^^uRvwFZ0LaNFh-4EoN!A7vmZg+7f0*`DB!QG635he-hE zS~$}NttC|Ft%ztOXneB-BM>PCuhk+J=DfKQoMBaUpsYEIjkVPVv`7f`K)i`Mj<-)F%2yM79%j#iJ6`?c1H4RF*!>h^~hI18SW$;aKcDxLEEt&u3rQX4^~2NjE)(d zfUZ~g+kKatl0G~H#Siw2fwnDeck?ao?yqFRkiz$2n8+M^kanwL)X)+OE6k(p*4FlfASM_BAa%65$1Vxzd>e}g>NWG>50a}aI>9ZyX z){*(fCHKru;U$InS$eMSWAa(aIf~ZYpv5(vu%jn#*7XJ|^y0%qlU>O>g52_a?sS*C z?sC9-P{4>-miN|vC030w>8gdaq4kPXq1s77(t5y*)pAN{Imyl^Wj%zch{s7cKohpo zY#C}2NiBJJc;dUb<%Q8WXxo9abEA{s=)`JtM7YxeTUt)*TyY13a|Q4-2B%v-II0I? z$7kh0GF&_k(p6!QqS=F_MkkNfZIfqyN17fL8jVE1Oc8-gJ@YFrjIZ&r{XQH~`HMgq z0~HpBT!ET}7(6qhNzOHn)Oo~1jkxfJ6tPeHv^b}Pzri_deaR=sSxYVae6haNBXK_C z-_7-x-A&%U9?aOQC|)R~NsmzHTf{*}J|*x9vlz+Zr@A34?2dtU2%jc(5P;`~UpEYri!9 z%Qb2{G9Yil?5Y-A!eC`J=SAax{~!Ms2bK-N`@OIW^TKLmX;tgOsMVY%LcSnKtA+dj zPkHas+(?o%2A;crMHZ%qlL;n3Jox}BNn`QRT{Fe$>LQz6RU8VH01`lU0h!sEi6T)X zWje`pl1wJE{nm8TMJJslneA=&pY$(TcaLX2KvvK6Xw9@^)5S!D$J^b*J;L3CU}Db? zpvDoY35NOHXd>i;eH%lsK}V|m;q>%)r_rdOa5z~aAAq!z(+>QvVo#tpyrQc7Veja$ zeRv85zn}7ghcnk$gjj82fI4kZ)He`N!{v0AWU4z7pA7H@;0zE*(nM?ElzlLW>C%nI zF{C7w2X&6|cFu%J5#tEss?o(|rI9jrYpkQrNk1LzdV>kHZqAZv)uUrS#g}dT9 zzVbiUeXA?2afR_^Pc_Gwv1iMM0}SOrZQ*gMJO38%>?vsLR?Ei!8n*cI(Ml{pHbe&? z=V=%L=cvTfp=-849W&HFc9WZspt55v-{5)OF zJtyG5=#f+8eZK8y)&1efRM*Vh%<@OlhEV^8X-w=yA?v$2X*Cnm$5{CH_ddNABe-W@ zU@<7^`DeLXcCFc{`r2`t>DSV&j#V|~Ys`4#z1dW)ea`Uas$VtDW__p8?Cx$ht*T$+ zKZNG-ahi+CBE@n%Pl|N)0wa@wz|GFb;6uxr&cmBESxSE?$pp^m&Ceq|2P@5=q0^s7 zqB>-wDTAihfIK@&*JRR3-Wlaokd0)fW`i#&EyS25Uw z1B?}+<>0V^rQ!`q1q6_+&a1-#%d`%13B9Xp5L|)5Gq;=AmhJRFWkCS<0plTz#ChY~ zvN61knA`r0$1~ZWSFF8tyN97%%Ii;dE63*=2Ty^=2l&l<|X9; zqz4nwZfpkl6wi!HvY|TVo?F$C?ZSVdqF_wJV=_NE!kCQl#>Pw&vg{IF6kx};kWAIk z&j2f6{INa5*e80NL0SBv0G;#wu6H+6g+kR9U=Xai@L(5+iSjF&3N51u1OnXk2K1CQ zpq#ajQO0oKuVOQ?o7?bzq4F%2CbO#%Ua}z63nVB>dKr+$n67&6L8Di1XL<(nOL9yA z?L(f8f$!(+M|0gVyL(V?73$e}5J)@p%+Q`^P6r9YV7Q|?J?~AYR7~6sFi}v5a~Hs@ z;DZggGDILLk()*(TBD3!QlhH|Tc>FLnhjJU!VM7@$sb8#Z{Pan9f&kN6cX(Gtge{= zP|FWs5}JicXm@*!qNjnlj({0r2c9o{R4K=5GR&m9T@7sZFVM%hICW!fmi**fpla-q zHeY-O1ii}{7#C(hzIzoR5#vsQvK7tq($R^2h3--r%tC14j9`pvv+#+E?(f-zace$0r1inew@zU`03J}9{|Jr z?A$+{?4g2mZ)TQL{3c6JMi#M^Wih?r{{C42 z{|R+O-XVF9OOnDuv^T{X4$_vV`MIqSwfA>RZucJ@&)AVE?-pP`GbPfgHvW6i9Du|M?#ch2U; z;{&!|hr|m|=XtknSqvl4@+^Z$4 zB=r`y@nY@=AJ5#;IsHBbSlg(apBk^@(7?H?*hT^)sKJu?lRwELTwHw@Z_N<~1QOmZ zx9z|S`Eaw@skTIqY8})TU;t1+ufHQ2JElk)p|~F5Z`Rq`3=@{lY^&8zH0_*e@y&*9 zfUs$_c2R}jZQ-e0edqz+zIG|P4n9`($-4;6@#fNw@HY&N{T|hL$}dZI9J{GMI$FjY zc4S93{kyr$mVuO6ZMnYG=FH|bZ_Y9$WlFIeE2U}{Wkl;`C2Tn!5C9TSjut0~K0uWZ zKYE$D>g?iVwc(%L4o+8dm!=DwqkCVcDa%n6h~kHH*j=2;h;)<+PkiBm(ha4Y%EBLy z=U&CuSH|PN7!ruJ-cs1S1yYlc>89c!C9wL_+zAQ?8Ds?C>008+`pFi}a$v7q2zhoO z1(Jm(cJ<`}N8 z^;cpwi`U2XUVGY$f#GHiiK^ShIbYgKTVq1J7P**HF_BfLzPDrN z)>_Z(+UwQ;bK457GQ$+tpqP^ptc%$NlL##@kKY<86lftM zgg!+GI`H351*5tWWjD4A!9`$1+|401BSE|1DiTy zAfsiGYpuiY;-u+}MmIymE4wQYUDq)vyuq70`*T`10heF8QlL!pI)pf^7gHtnap>I0 zVtaW^w|65etGi&l+le2H%?oG$0%~#`XT-McSr!m@*rq(|O{+~*b7Tzb89vZ%p$&6& zrqmq_U%YOOqA~$ugxgSb5U8Dc%4~FQi||l$NUR@?spjPMmssbCx;h)o0JF?`Cs% zES$Z};)DQ^FAq|4O;JsAdCxVqF!Vvj-%b}Uld!x zZG$?8LRASH`wjS5iWlV=S&k^gIMnK+WK**E_xGi%d(iBSpMxS=--Exq__t~{Yv!0l z6!@>#=tpAsn+~9y{Dlk1yz2Nlp}efj+iwXXmDVWvAi!)xESib3;2apYHY?m7e1U1G zi8n^l9#lYN4M6o;U-)Qo8arlEEGG_Ylgz#tXE)-K*4(Ty>AC|V5xy|T5@ov11tC$h z-}z3zBW~8@eRH$s+ih_(eEH=!!@Q-F@$`|qR4uo7Vam^45QLq~C<~<^V}_PE9DS~PmJ%OcvD0-2RM1zQ!S6Hn_{LC znWE2B=@IW$AY-4)FT5aKGjFlQ=k$x`?eY7kxtJWZlZ5@TFga;%a?*8^Gq*CtKp4i) z67eLXH@BatvGlaD(|r&J#8l&H80Qa)ude%#og4(ftmLt1-%ONd&bon2_x?W7Z{@K! zm~3rq@K6W|u!nw*Qar0LUZ*$%{17>D_SrcQMqDlk$A!rX$|s|t4hT2}XP(_CG%lrR z52a{NNzp+O_{zKP2RSJ^ae#qI!sEGHK~9in&vIpXg)39Oz%W%=Wul8ApkhLZN%N)j zEmydYsoj{pNAdREdyuwbJnXKo;J?rO^$1MIo2Xm(Zw3ERdg%e!NHiuTw2>4kl4^as zYX?FI4{}PT0z|Ol5@^q+D2>N+N)h0x<;uaAuUPpi#f1^ZIiZO}Ru}_{7YTW9tr>Aq zMP^lFk?e}8?KjtWUMtN{L}t_x=cnc8&Ol7R>-Gj&R+*Np<06r&x&k5qQtMEL7|85S?@no@7rYk*Y zMcED{J7vz;H`yMS6Xyb5z`{MRAYkc_Ka}hbC6bj$7jH#;yWU|3_48A7ywWA4z+1-d z{I!b_n&#xSBVJ))}Bet)h4dSv{vtQ&(JA7eUW!Y zZj&>zos{M%M++AihWi|n`tIhY6{zT#VU@pNg}RN# zniXO>xix~sr`D*^czlgyers)h!fLN~a<1m}Hp?PE?{+@3#WT_4d$*AJ_pWf(**npk zz2mI2H+1ex9lJXjskZDYs%(+v<%)FL;H1cWgZbr6)2nstb@{iOPS>k-vrmoXDE)C> zo{hMLR+`H|#NC34duO6q^prjM$%=lOUs z|C9Tvpi$#{-eJNlsDyd@{QEJ{}e-L^oWyRk6p7=ovyB zta=`TokVF9z*PoeIA{CPveOf$i=gq1+*L1;mKo=AmUJC95ezOava#lF!{QogAzfng z2(Wqdd>j5jYv1^4gzN`jnxIc)Hz^7y^rMA8K4(wrOCo8EACIIFl`ybw-(@XJx*2Ox zG-g&cvR%=i0tkL^OQNSi>Ho+4?N51UN0 zTs~CLf)3$hyCDbqMq?dcN-*v1a)P1su!N9W8X?VqkY>*zsXt?sG*gr`(>9NRn z5-!vv&G{N4-2DfLaHNQEULZnYgr3=#o+3kzn;3{hQRK)*2XFRLmNZpX$Se0YDe`FB z9dD3b_-oCvXtB^@f-y~cXt9&&!5(w~HzB&8NP7H+Q8xNgY@1)azqHouFD)XM-5hCj zIA#39NFP>BaSNvHARstOlG|L5{5mmit|tJUOgFPc!08L0W2&(xQD*BXvVxpdO|+xu zwJ7g%O;k>K|CH@%9c6U?*_5GVuP-Ev?JQMHQ2t^rpaL(Cvcg$@oQyi{@X$+ZEGa|ZHa1|OSE zm@>nT^bQU>yEY!ePAJ@sNCYaMJF&dS#GxNiI2wR&@I`!0)~~g>h0&Yls~?sq(Fa8O zXj935FpvLK+nd*V+Gx+2|K{6_jCEqcwI(YxjL?5Z^M}A7!pzTxg_HR{hJT#By}eAR zq4lmo&F!6?omR8^d-QuL`W@i|T!nt?79zlznK|V$({DVa$zj#FAP_B;ZI)>coWQhl zm#G8I^JOHy8MaD2hT~*Hx9YtyOiJvbn+;mdybh5NK|f^yukmM4SY}4UIgA8xOvgpQ zb~ldwPu{5?!+wO`CBY#j^niu9iPpf>c86h{5)_aHJ2@7VuKW^g`wSZD2JeMjP_Hza&$y00U8Er%YEGo|-WYR!$hK_U5KdfA?{BzteD%-zCI# z$;L6(M)cUJf}XwZa6<3$qf=knR>}DdvC79m#g>{=j$MA#gBmhBxHm_jyU+>F$l46W z7eCg2CvxA(+;=MXy~uqpbKg^LC~B7VRqJ~@JpG+Wf0s>vFVf$O^uAkuRW^6ZX1zZz zyG?4=XsNeIkek<08gS~{c)`TdTaAX5N3pC({1lR9pi9v#t}_AQe+8~(`~LqKwnZ>i zk;Jx0VOu1yEt1$4DQt@bwnY-#B86>{z_v(YTcofpvSodMJ-ZUyB3ss^rN0;H??w7! z*oK%QRuSZmvV{PFg5dCU^p8zj#^xlU?Yr|==FD!|^=-8N&^+AZy40Qc&GQ(6>`^%` z&#Pnv%&>SDv3O2KhNfnR$a~So<8rb$53D?XYx>ud*sWj-xXqNbO&B+6Y310iH}(WN z@+U$ZMEZ;hqgT(^3Qxh1*PpY1ztE!^0cJ$KyA5TE+a)TN94^2~FD59RSy z-0pUE_bj{KXrq-@o?&R3!c+69Kp$lloB#Bk31w}N>9fyn%VsD~0+mGlSxq8de^jbrUviTBL>K3p(Zn6&+iwox0Kzws^@v5 z?dGOiZI?)=>S*^#;Z%bD9YO>1A&J+zgT!myLGs;vf+y=p)sM^FaBwbAyvjE!t&(V` zawPyiDOa(j3k*ZT0O7V2&6x9wZ-oUdY%c(MmI@QOCqHTb-h` zKv%$1O6Y)6`7we428jz zoqD$#*;BkJ8CRP?RZ(BgN8ahp=4+LAD&4;Pnf!0y4 zFRX8D~GCMXZF0_J!n;D)mcxQ*&3v5w(J&jHCK(o zZ07J2rgT}qtwr@)djMZ6_*&Tu`1%ZApY4ej7;0LbZVsx0%|&%#*%yupWj3KK9@^U{ z_;Uq6(e0tT*=}r3X!TZ@{u$Cg6WB2<|Jc59j;qJ^k<+RkSI72CSd6iK?%Y(d!lUZN z=F2KnYoAfd3Q|reWn~{y%4bMfQOf6jaT##6&+Rk&u($v!i<8t(*cw6HKQaW^q=44ORux|b z7z5*9BlxlkGV+Mb!x_NQDsEqVlUMR*jpMTs-{tv9ANCYT6bFeIAKXnr2gU6zQWnMQNnj%z?!J z`sS4u@=t9WpWaxjPNhPaP1mba>3VglbX-b;D;*d2FwKwGEJeOs!*<= zOe)N?%#pLf%#vxYZUW~n`_5Z^*VY~wL0iU2$R4}u(GxM-`1_dO+0`2jJl+^C=dOyz z*RV&kI9y;H5|s#$E&G!{4ZM_vhFvDT`ksv;htrvN2t)JJ<(S@=`&{T#Gv6s_RrYGT zyAASIu20#|}7@b62m|Z-NI5B6>)@kX90`Q%;(>L1GV)XCl-yxPxY| z!D?3h+jLB~mP_N&)pLWWZZ}|u+}ai~DOI+<2Wuw~`C64NSuQ6t+U)DXJY*Igdfo)t zEWo2&g1nOEHR%uOWa`l}uonGiz7BQ@ zSyz#3KkKP@TAcCv8lkZwh4|6l(VDG88W08d(ZHFLtDtcw2C4s#&CF{;`aJ-?W0oyJ zS^}`idKVSJ0(`d!-?D+z)jRm`6nhPb%h~(}Ate2b=e6{_h~+U6JXaWX1Mc8ZD2#dH zttIP$s^T}=A{OnY>D5xJ8i?KL-PGwe?AwGMcox3MztD?By4$LX;%+C7FX9+i`s{fQ zv<0xyXF*8_A@>kwQ9Bx-5nvg|anLVpzUj1dabkqPA&Yt()cL!{cx}L7f!)vdUHEpL zxg9$pMvWldeq+PkZ>URe=1Ch9ZiJR*)c@KHL0>ENe?W)7wK<>5b7W-S-z&Yv72UriEIYKjmER4#drw`8k zMIj>$&X!E6=P{=%*i`a{z+g+|*5uwpIWT6Iz{)W8DTVKNiGetn*DJ;F@T`9D%yDW> zdUKtrX8{F75|i{^q9@ubjqQksLiLy|*b8iJw7taE=BF3iVzfP1JpUEis_(t|gOdUy z(&9J(1CoIc`pJ!t${!;EKs`6{DrYdpcy&Z)RpUzUPK0vt>mU)h`h@Y2uB|Xt(6tz zv7d}s_>pzk%^X<={`mg>*^>LN4hkqgqKVL;G1!erRD}R*L`(qmvB;IxnTc}!%0XGV*>7!Goj721_lD)`p8dV84h!VeLSimghLbDNOySgp9y4%@n zwAwAnFl1){=UJ`!VQVnIVQ5;Z+#t_AHy+Jivp0chm@{Sjv$UtUOXfPC_m}9DjwVZ4 z$MCs8xA*i*+K?Pj>O6SL(=DqLh;@n&WoYYTj`efg%3LSTWM&6d!YvW`dLBsZS2?fuaLs2Xb>cq5kc7;TO-=xIjf!;k8Z zj(Z*b!>{9ZXQq57T5gkW=nZ{PVju?`Jz8j9&Hz_&}1HlarR`PDyp#T6K8OBajh@YiLLQ2ZIRmD z%qnr@%`A@SFpT&X55Fi5AX}^Qg`!m|(L|=}8HQs2qSewFo2nUGiuuyLV+Sx_gXh!! zK+V@;{d_Iud`+C?)gm)r6JSi;GDg(OP8d*H7?V-!IbK{njnounTHw1ZD z&)%*Ey>yUZgQ)&sFwUJvXcBlfTFx+@%{wp70{=2~K79SjjaQ)58=t&U%lP!;r~cQp zFD!thOv||Y`YT8?9AgO?Urpx&5o-yOphU-%CZF`6VE^lfuRqw|V7)--BOf`6F#}qO zj0yU0_P_pm8Tcqtu;0e=!e4lOnMj>jzVQG#mUK;#2d52I9;icg#qNK-wPl>+#h!Ot zOE4(D0h2uY8UWh#)oz>g9kpqAQ5%Lb!8dJ9_^e_@ZL?7aGHFtr{zkh&FBI}L~t7_sjqH78=FSEU2nHBpC1*n8Udz$d%J>s0=%`L0r>j7x}~YYuC|X2A}S*Y z{lxp4jg!84H`yZKr;j})T#m3MN}H(OV;cR0M({tgU2hmQqXqv$0^~wAs~v#+`YrUz zudg7l+1&w{O{3Xt6RcnVjKH|Q#;2xi04<#gi8Ll4ZJ?ey zD6DPXW2muJUL&>6%QrjXv$fMupUtvbd9^Ooy6|t!Pq1vCTDCE%f96fLj3Li+>$fZ0 zaOJ@x3)2?uP{%o&*_UZ_6Tj)2uCU23-dLa3>W$eu|&3%4o**Bq`BgL zh0?n+eG+@WEWKc~g7hYX4`ajhgOpaf(T6|JjV}BFj)qNq#cBuiQ&mNc<5g(Vz9FVV|+yWZMuH+K<9NAOPyS!0V$d7k?aM?el_0{1zM-RTh!z!(-1P#Z=7 zr8Ry5$(FHY&>o?u+8H34A3g$PZODV59$2$3q7#h%IK&uQ}-jS`sNw`~HT9-{1~gJrwcz*W$@Mlf2>b_u9M|L$o$ z6MT)&pUt~!=l4Qc@i0^11uyVoeSuM?z!5KSw7$SNQ{b2vI4&z7nn1LHQj&dW_zKHm zBL@NI0eoXDFzs+WHj?Eqh5Z{%L~C>Zqer3y8JQ*mUokI%nv+EsrZaqM9p-XxhvS0U zM;U2$X)|HO(6oq{Sl583vYIGIumL#|MC9e1q*c+dv;`-w-t5wzh~!(4QFs%;aeYm2 z!TK-xjlQT8eWai|CYeHyExoWdLOhE=ZeUXhnlZ^7*+kQ>%KUznV5Tm7|6F*x`zA5b zDA#7;?7s8NI~H&4d2h(j zoX^qZ6BNRXlY9-m@NJ3 zt_6IR(*vS7{FxnkfU*+%w?G5P_ve?scOz3um4&ZR`uLE?EbNmI`xBH{yts92h*9>n zT&@)8v{o{j(&1n(dsvH6OAFWrZ9+V6>{AAey2jxsuZ&Islt@tI#w?x?PM2aJRVt*_ zF_lnERut(&nO-X?F8deLdSL%HsjpShtQx|!05Z*k3=1Gb0iuluK=9?UW$d+%O|cF( zcEPIa(=uHHI7PszKE^eGLj)YMw#yhAFtaIb6gv7m*xr|rL!LvGkVof#OX^@6_TND? zeD&R6Y%+2Q`DimLF2yqfZFm&gjEo*TMrGQN`vZ5J{T#PP3zd3p>lKRLKWt zi%|kz$ze%3EQ4eqvx%ynMlB_q`GdS{_9-^gfe_8$hc^(C4g3hybBZLgymk|egKn!I zp8f*`8flr@OKl>9o+mA~dx0k1Bm-f1JLx+* z2p;*qOudD9%3cTZ9d-j(D3&^ZT`q=R3%(`to-Y_ zyCNGkRfU(ULV&PZys}!zbXl(>$ko9BSPg+*1F6DicqgxwPIzgR$x0@ANrj4f(U=$2 za<#Be>rlb92+=;{8?YfZVV7X;bHrS9cFW*uB5~E`=6<2YUEuCu(^CC71HJ)GX$kIa zZ=fd}dlPp#PZ22}&~h^zIOm@Er{`n;lR>^8PUWUH0YWfl^ry1_d<*jS|D>Vqe83E3 zSNJ9o45ZH<$@qjnE8Zty;y}60Ju=(7x<K%1YmGAu~k z+bQQMXJ}2&BG_Y06*DEX(u4xu=np=TRdHgU30wD~czod_$F zI2Va0&`GY@qv;(k)GOE{0WLNxvByIDACotCA)8Fxy%?>sD)vn|%xLb9K341_G;n;+ z=X->^`}~k1xeLc+44TOM!41*YcSXGpRtj3^))Vlui?B!>a;$l~%|zl%_gq!@r@h=M z5=UC1yRq>j@-U8-7kFDNhz2JAE_CSpKS^`*aUyI0&Yg%^_u#C-0^gtkEnZ)5Y?v3$ zxh3)Eymo=i%g-+YJ{u;m^`=!QM_A%mT0iC^D|7vBfw;IZPCy)rStB=6WK_Wv7tP-Kfbr3ZeMp@2x|anK7N|gZ6K5hG2K(sjf2{lCXO43yqCQ%-`ID2@!{A$# zUPa^bO`V^hWAiy|abQAk6Nc;mL|R5}$SfeHBNIh8-O+?Lz*L_&@5*r_z?U70j?lbMUQOHQR_ zcTk+giq=%;O*-(ucH{4qrl^97EYs9)T zH7?`1`3Jz!PabfYu~jidERPD_bEzUDKOW6JV{}X70(@>`9!uSSKK3RF8@U@}JxJSz zKXxjz<_b*-jDN-c+_u;+_|wF70WM%Le;!ExBaR@9Y9t1$aYBQboP%yQ*1$I!s>D{d zZ-_6{Nctq`v{a0kceM87n_uF0!-inBfA_~ z)m4AN#Dx#v+#REka8Nm`^eV3^58vFq1Xh3Q--0UL1U>hgyL0{b2kCdYsQ(O%)vOp5 ziyr;pgS)z8u5^{ZhBp;^?5^--0(QWfYKHB$0BeppRFgv`)U3$f5!pL3dq>M|H$;BB zApv0O9Og)20^xjUi^NQWXfSmY%o{1MjKzQT@%CRIXn z%N+5v1bn;9lIYQ}u4!vo*cXTrw`hos|IVpz3mhdz3KjH5;V)T=ptV3Hee%7V7vXKi z{?ITQ&{2S>L+zPr!)?ymgF=Xrl}Is?U%UsF7XckZS92?f%09AAjNbIG;XA;&S(iKOGI zrK%!>+UHJyUQ_J!L3xbLoS-(spl+Q`1LJ7moqpuZo{tae?alg5)tqgOtzJ`{voc?L ztiT5Pde-2qhpY%f@>~|3V#*IW_o`f1lXTzP&;- z9F)&+@;t@hNe<|p$-W1l9(+FJnih4Wmh6N`^0`A-tvds;hKoeGtMQZef#ipiuWi0($WAlF1I z5VxW9%?ujZxoxs^h0sQ(iRkQm>@PqiA1wjLmnn)^HIh*GpNA3lWWRa)e2agI zq@7|?yP>6Ru?}-t%P1-WFhTT}9sEG^0VoIF*k3Mm?I62Kg^rUp!RL_@@Sn^a9?iqV zlk+Hg;|I|a;82~f0Pqx~@r56dC<};6!YIn3UPSV9rEv1ytalAJia->_gE*S4>`H83 z%L%6zxwKG!(BxEUaxlJ4L|yTL~|e4ES)VE!|PtY`p2PffMOnpnAO@} z(rl*JkAo`2CA|NV+CeiKhrkjVgT`Ptx*f#Rp=&l$a0P%X)Zqz&0b!DqWmd}wn zN8-IKDsYYSarILF7k1W&tD0F6F5Q}|144G6G}1lTf&h3U*oQj|dR_2_A=QKIWz zF_2&X<$q*{f-D{>RE~&awyw=A%C#B&n(&#pCluF&D5>EkiG%M1aakQUHF5KRVs2JF zIdNWqn`t@-dm;%u8J4bemt+(cMD(~vmQR;8K)%c_bS11;l=)_Vy}RL)XxV^+QExLx=4J6 zca0dvE(|Wh>2&UyECK(8os(|kXl@V!+drBizW}I_WoZ>gCcjsFh8K@mKClj0aeDTw zaBgoeL7458UVpe+y#RHGbx~xUHMawDO;(P1QVU@|y>>rzPPkNcyk@129J73>j;$?I z6TvK4IZzYvN_6W8MS6KnsT`de4H9rSUshKZySprzE&|zia60*1HHF~yu*7%nv~lBY za9JG>;^IhDV6U4(psW!pPz+cjh;qMVB zMfmq6krL=DFImlJsBOJOZR-%T&+t5wnJ^sI2LtxiB*>o-^3dx4#PffW`8$;V5%Yht z`X71zN0|>=>n&D|{~obse?j0QZ1x9i_7~BsUs(2A%>D({$y*!(rKKq*-cX`zrYTGP z4inQ9Yf4hA>O0U;=_5%+r3r^Up&AkbJ|&nF33HNC_r9ZlnYOuN+UDETerE?M*Er7^ zO;mpU5C0Q1>0kek|6U=j@(25EN*_~zrjOGU3vumb#!*LnOGM5jF%(AS=G2pycrQ^a z`19O6;~F)H!*5e(pYHIX%?#{Yd(3{5WKgkTUZxh{H%<^M9m~=&D?LCb%@y?XLPMtr zPgJ#fS6Hur?0*bE`9)ylE(a%|C-+Xw3&djJO{A6$xLWqj+`JNX@IGC$rI>!{QEV%B z{CZPEFOwPlo7v^*d@Pv(Tm4vLXKiY~$w*$bdyU-4Pu)3Qz~;8u;yG_d(p=1I7=W%) zJnS75hr|V?8oL>yf^4U)asL8cTM&CO3{32~LVG|#ZRn0Z;tf=7IA6xK#dxiZT!C8W z9-i@s%cx?wvG3OCbj0D_(CBXfA_1O`EMw4orXC%~YW>y+yaWj@MyFHU@kbwF*TSP+ zXjq#d5_=PG;ST|;jm41d{io+|&JA}oLicWde#iyaXC;T1pEBFM3@ze0S27xBWlVby zAa*73=N^451NW2b&(XT4a^3$0xFq3M;0y+&@B_gEod*^_no4YTGKFt`?#DJgcF55_ zbfyEk2M72NB?TxtM^?d(!~~<@2VP@w;03BZWRFGmm{>=}3rv>n~%fx6v3JH49Om`I5&R-pPX8)SBCg6D|eD$!)2&wpMnh-DU4{yroAUtN}rnHJRE&ANCjsNN3loOJ_Z>;)Z95=NBpOf4(03Nq7_Rg%e{czr-pK zKvrD^B=0bN^h=JdI*%P&X)FEI0o5A}ORgPKxuxA93(8_=ShDB}{d&41tWd5S7r3U!l^$~ zK=EhVc*o0_PG@ReX3ml4$1wII8hhnA>mH?6Ec^8%cTfy7U@rjOuEFimjhouuwxQoE zMYV0!{S_03Ki66fl#{ex(kJ;p$-cI!uTL!lqZfJ-30D9`@maeJ|AZ`ei{ z;BRW59$A;o)30Ld45-lfe==B*(gLo#S%pBCGS>Ekq{`-cQ8Xuiw)D=FinT40O#Yj3 zavRM7M+_BYFv$y~Ac`KZ)r1lC=?G_EU_*fmBKPCh@VU*hd^>MHPWVkJfdQO;PfBW& z5zPT}XLtk~JC!3|EAF76s)CwdS-bM(_hgEVB@3pwY7O)<2W9!|X`b|~M7L3hvQd|F!#cz%Vh^y={!bVB|&cLFcx%@$0|&uNLTM08wNSzoj8M z5MAhJuqHd&G`0+Wv`P|IdFTWrY$`jWWXwpkO>O57fzJ*5o3K`D`&YN8+uV(vmyPD%zaf)OPu%$&^ba zUQ-hi%`!$j>p0O9)0ZqBHF5d%-~L}YWGi7OYYeyePEing%JeMOSxt##5{mjy>}Tp~ z;)lE?g1DN%v-h_n^XHLW`G$DKDZT#{SoT$5C)dtTcpbs4q8FY?j@P!UK0~r$XyBa# zd{ioU>A0%05IV9EYo z2$Kl1uV`lh*bn^MSHu(h-Inb`*s0<@$`l=(A9?@I3IWXi#`h=}l^t zam!6Nb@ttq`BPmAf2!Z559;LwZQ|6R*(_hu-)lATT7v|kH8{yZl{J`TN6p&QYRitA z*{W(I-`IduX0TeEkAJXxdeC_h5!X$#OA?ID_s;%%_5zS>zVD*3sjJx-L!PoX?u+oX z!oix=eMv^FKfZazW7fN|yGTT!F+5f0PwZkQnYNmm54hDo2BhBD_>6(0FUj2G#>|)x zVZJaQxZJ3Z8v4kUGMwQ6!Xddj8~h$Ug*VH z9ylU(o?UKiJabcN7~|prqcNpO8PUwV1Ce?VaH5A5qX1~VwoMl=z03Q1cA;pq-F4uP zdu}QdVG~PxetJ*=H4JZVdo2Bd+1dCo`?yN%Uxo0`ohDCGn4y^@N2&9LeWd0qBN=BJ zra6K(qg1uEpKY2JCblC&vIo{Va}7g>&n0V0T`@eeWO&EV<+4ImH8w_I0ucuy; zno(*&seg6&`lZorGMFunzPK)gsD(*#;1mY%(m zey^t2Iyh)p%r|^12=Vw6HuL*VqjT>qqI7j1@LK_`U;SBnz!3cV)6-Wk|9VofdM`xM z$=U0RcaT88KAg%?(-2u?7UP?{n-qP3CK#%8zPe*%)3hG))OEzn<(O>%l9I$m(x1^g zni6hI8OK7ab5vUAOC)-%3m{xYg5v6fxX2|@4X={mNTARx`OnGV4ww#`?Tw8a6MwQh z{4?hmEggix7xNx=F1Z~6Fw9%D{~36UcRbi1^}I7I`W}nA80#nH78dU+6rxI zdd3OQV0`oCI2(keF4-wBPPRk}2A>J13>9}ouV5r9mjOkz%qe6F=iS~*JLlZpTRkvq zuS5Hiti3|(;L`jFhzZ7yyN)0)Nd0IxRXU?FNJR@iN`>zq?6%coZ1mE63lsjpkdc}7 z9ik=8cens)sx0}?&`%ieO_lLppA7XhlfLhCi$1b&gRfKgdWX4h$>1*_$alQ>DX(=v zsiy=nr(y%hnWx-_5k7gi7cbA8X^_K-huuqA>0L||`lJWG!TjDBsmRDi%%1m=4P z_6v=B55Hx9Fn=akNryHK0GKg=nIcLw%>>dVf3yYnM zWRa9$FkiMh{ot;54;qCdCCoie3Ji_kq=?10Z0Ok4A>lINC=LIUJ`qEm`}98zV90k5 zlDlNu8S-YPmJ;=_!B2u}PO+h(Z09d}J2$Kyh9OurGktq6yfO#mk_odFrNVX$=AEl; zmm}CHA}YkxMVNi2&fTOK!-BSL`MY^d!~QXKE~rsjogbm}D_T-Qj+hc(3G8}BBmPla zy7L$zb2f4>Qsw^$s}!g9_tUExBwq7Hf&TxPaznNE<+FI2nMElh<3#>NOyr-5{^dme zOcS|S&&7o%fs9jGb@x!)!JT*sjkCa7!V+I*MIwuH)jwxY>1WZQ3&Qq4%N~t0#PoXY z4%R9osg_1kDF2~Bc&eyKtjUa{?~hb$mU4{wF}0gJ(vg>5@+8!`^z1jDK%F#j4zW{S zK-@bJb*6#7V|oGXm{5psnVt>VZ0&A%+wYlqH=)cc;t{fY?>R`EO02@}0Zwp?mhRZ{ zPOHNGq^aXlj}xy*E7xisdn^Ng&AHO{KdY#Y; z`C_<{&mE!3dKJ=PMqb8b)SobC=!9kt%CgOd;9!OU?ym&*iov~NaC{|BW5y<5Cu}L0 z%QR8f%NW_?X)L^=(SQ1{kVZbtM2%EHdP6__v2WzaRRLsu&ode2Ug**b+srj%X+HVa z1;mLtR(y-2j|p$S;pFfwkpsmXy!6z8RB>&qZJ6@q!2E_$yF?V7;>!^T!DS=^9sJTG z3ctl(Q2!=`wcld@mPB_Gpuq3xYsvPpB_GL%HsvJ^<&d`25!<{+d`JF8uZ*vQUQ#fxx#%( zJjE+l1lk~m_DyP2XG%%~hx5#Lp5Spm&_KUoLJDF353IXCFezoiCuHIy+=SpF8rH-I zNsiG)z**jelgkk$Pkf#nr5V9pQX|{)sgKCWQ3oa(c*WBA%gB`UJ?u*St!138OHbR7 z4n6w=KWf6fH+tTi#QyNcL*M>{(FUOq{yt()oHaDh{-dNs{qfj^tE7zV%4qJ=`9-md z(DG5`(k0ZCE1xM>N}tTCUIBZc80*~F&^6MCU7xeo@WJ#Iapn0?KnG z8^-U<4^*yuo6mJ`8Nnm%x+!ZKs#|#&E|DV6I;eu<^no75rmwT!cH=i%7Yk#9$Lxy9 zZY_UtZ;0OYgbix9!K%W=8(9YxY=l)OeJ3J(#5J#Q6hSQ1nzv zMRGBH?zFw#ek_yosE^)i9Nxh4B*Ydj@o_#nYoKemI1DKW6?>o^UHy4(4n#l4qMu{x z=NYQ<#R)-}OoDTn=>lNaQ6}N%>`9rA;Z@Oz$1eEg$(a>hy|((W|AcXR_rt(&6C#!{ TfKBnC|MmY1yc@r_&+Z5SHzS71 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/11.BbfUOvv5.js.br b/apps/dashboard/build/_app/immutable/nodes/11.BbfUOvv5.js.br deleted file mode 100644 index da4e6bb598fc6dfc924c7b9d4fd614987c537713..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4831 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 Fz5(b>aUB2v diff --git a/apps/dashboard/build/_app/immutable/nodes/11.BbfUOvv5.js.gz b/apps/dashboard/build/_app/immutable/nodes/11.BbfUOvv5.js.gz deleted file mode 100644 index 5006ef61ec5ef1a32ec94463d060f21241bdcc43..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5415 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 w=C();w!==w&&(w=re),T&&w!==null&&typeof w=="object"&&(w={}),v.ensure(w,m)})}function Mt(a){return a==null||!Number.isFinite(a)||a<0?0:a>1?1:a}function ne(a){return{novelty:Mt(a==null?void 0:a.novelty),arousal:Mt(a==null?void 0:a.arousal),reward:Mt(a==null?void 0:a.reward),attention:Mt(a==null?void 0:a.attention)}}const It={sm:80,md:180,lg:320};function $t(a){return a&&(a==="sm"||a==="md"||a==="lg")?It[a]:It.md}const gt=[{key:"novelty",angle:-Math.PI/2},{key:"arousal",angle:0},{key:"reward",angle:Math.PI/2},{key:"attention",angle:Math.PI}];function oe(a){const C=$t(a);let m;switch(a){case"lg":m=44;break;case"sm":m=4;break;default:m=28}return Math.max(0,C/2-m)}var ie=yt(''),le=yt(''),de=yt(''),ce=yt(' ',1),ve=yt('');function Et(a,C){Rt(C,!0);let m=ae(C,"size",3,"md"),v=y(()=>$t(m())),T=y(()=>m()!=="sm"),w=y(()=>oe(m())),Y=y(()=>t(v)/2),J=y(()=>t(v)/2);const St={novelty:"Novelty",arousal:"Arousal",reward:"Reward",attention:"Attention"};let N=y(()=>ne({novelty:C.novelty,arousal:C.arousal,reward:C.reward,attention:C.attention}));function H(d,l){const r=d*t(w);return[t(Y)+Math.cos(l)*r,t(J)+Math.sin(l)*r]}const st=[.25,.5,.75,1];function nt(d){return gt.map(({angle:r})=>H(d,r)).map((r,c)=>`${c===0?"M":"L"}${r[0].toFixed(2)},${r[1].toFixed(2)}`).join(" ")+" Z"}let $=q(0);Pt(()=>{const l=performance.now();let r=0;const c=b=>{const g=Math.min(1,(b-l)/600);F($,1-Math.pow(1-g,3)),g<1&&(r=requestAnimationFrame(c))};return r=requestAnimationFrame(c),()=>cancelAnimationFrame(r)});let ot=y(()=>{const d=t($);return gt.map(({key:r,angle:c})=>H(t(N)[r]*d,c)).map((r,c)=>`${c===0?"M":"L"}${r[0].toFixed(2)},${r[1].toFixed(2)}`).join(" ")+" Z"});function _t(d){const l=t(w)+(m()==="lg"?18:12),r=t(Y)+Math.cos(d)*l,c=t(J)+Math.sin(d)*l;let b="middle";return Math.abs(Math.cos(d))>.5&&(b=Math.cos(d)>0?"start":"end"),{x:r,y:c,anchor:b}}var P=ve(),it=i(P);V(it,17,()=>st,rt,(d,l)=>{var r=ie();S(c=>{p(r,"d",c),p(r,"stroke-opacity",t(l)===1?.45:.18),p(r,"stroke-width",t(l)===1?1:.75)},[()=>nt(t(l))]),x(d,r)});var ht=o(it);V(ht,17,()=>gt,rt,(d,l)=>{const r=y(()=>{const[b,g]=H(1,t(l).angle);return{x:b,y:g}});var c=le();S(()=>{p(c,"x1",t(Y)),p(c,"y1",t(J)),p(c,"x2",t(r).x),p(c,"y2",t(r).y)}),x(d,c)});var W=o(ht),Q=o(W);{var wt=d=>{var l=Nt(),r=U(l);V(r,17,()=>gt,rt,(c,b)=>{const g=y(()=>{const[I,dt]=H(t(N)[t(b).key]*t($),t(b).angle);return{px:I,py:dt}});var j=de();S(()=>{p(j,"cx",t(g).px),p(j,"cy",t(g).py),p(j,"r",m()==="lg"?3:2.25)}),x(c,j)}),x(d,l)};R(Q,d=>{m()!=="sm"&&d(wt)})}var lt=o(Q);{var tt=d=>{var l=Nt(),r=U(l);V(r,17,()=>gt,rt,(c,b)=>{const g=y(()=>_t(t(b).angle));var j=ce(),I=U(j),dt=i(I);n(I);var L=o(I),ct=i(L,!0);n(L),S(At=>{p(I,"x",t(g).x),p(I,"y",t(g).y),p(I,"text-anchor",t(g).anchor),p(I,"font-size",m()==="lg"?12:10),_(dt,`${At??""}%`),p(L,"x",t(g).x),p(L,"y",t(g).y+(m()==="lg"?14:11)),p(L,"text-anchor",t(g).anchor),p(L,"font-size",m()==="lg"?10:8.5),_(ct,St[t(b).key])},[()=>(t(N)[t(b).key]*100).toFixed(0)]),x(c,j)}),x(d,l)};R(lt,d=>{t(T)&&d(tt)})}n(P),S((d,l,r,c)=>{p(P,"width",t(v)),p(P,"height",t(v)),p(P,"viewBox",`0 0 ${t(v)??""} ${t(v)??""}`),p(P,"aria-label",`Importance radar: novelty ${d??""}%, arousal ${l??""}%, reward ${r??""}%, attention ${c??""}%`),p(W,"d",t(ot)),p(W,"stroke-width",m()==="sm"?1:1.5)},[()=>(t(N).novelty*100).toFixed(0),()=>(t(N).arousal*100).toFixed(0),()=>(t(N).reward*100).toFixed(0),()=>(t(N).attention*100).toFixed(0)]),x(a,P),Tt()}var pe=h(' '),xe=h('Driven by ',1),me=h('

      ✓ Save

      '),ue=h('Weakest channel: ',1),fe=h('
      ⨯ Skip

      '),ge=h('
      Composite
      %
      ',1),ye=h(`
      ◫

      Type some content above to score its importance.

      Composite = 0.25·novelty + 0.30·arousal + 0.25·reward + 0.20·attention. +import"../chunks/Bzak7iHL.js";import{o as Pt}from"../chunks/GG5zm9kr.js";import{N as Kt,ab as qt,aP as Ht,b as Wt,p as Rt,h as F,d as i,t as S,g as t,e as o,r as n,a as Tt,u as y,s as q,f as U,c as Ft,C as Xt,i as Zt,n as Gt}from"../chunks/CpWkWWOo.js";import{s as _,d as Ut,a as kt}from"../chunks/BlVfL1ME.js";import{i as R}from"../chunks/B4yTwGkE.js";import{B as Vt}from"../chunks/DdEqwvdI.js";import{e as V,i as rt}from"../chunks/CGEBXrjl.js";import{a as x,c as Nt,b as yt,f as h}from"../chunks/CHOnp4oo.js";import{s as Yt}from"../chunks/Cx-f-Pzo.js";import{b as Jt}from"../chunks/sZcqyNBA.js";import{g as Qt}from"../chunks/D-gDZzN6.js";import{b as te}from"../chunks/DGcYlAAw.js";import{a as Ct}from"../chunks/554JRhq6.js";import{N as ee}from"../chunks/CcUbQ_Wl.js";import{s as p}from"../chunks/A7po6GxK.js";import{p as ae}from"../chunks/V6gjw5Ec.js";const re=Symbol("NaN");function se(a,C,m){Kt&&qt();var v=new Vt(a),T=!Ht();Wt(()=>{var w=C();w!==w&&(w=re),T&&w!==null&&typeof w=="object"&&(w={}),v.ensure(w,m)})}function Mt(a){return a==null||!Number.isFinite(a)||a<0?0:a>1?1:a}function ne(a){return{novelty:Mt(a==null?void 0:a.novelty),arousal:Mt(a==null?void 0:a.arousal),reward:Mt(a==null?void 0:a.reward),attention:Mt(a==null?void 0:a.attention)}}const It={sm:80,md:180,lg:320};function $t(a){return a&&(a==="sm"||a==="md"||a==="lg")?It[a]:It.md}const gt=[{key:"novelty",angle:-Math.PI/2},{key:"arousal",angle:0},{key:"reward",angle:Math.PI/2},{key:"attention",angle:Math.PI}];function oe(a){const C=$t(a);let m;switch(a){case"lg":m=44;break;case"sm":m=4;break;default:m=28}return Math.max(0,C/2-m)}var ie=yt(''),le=yt(''),de=yt(''),ce=yt(' ',1),ve=yt('');function Et(a,C){Rt(C,!0);let m=ae(C,"size",3,"md"),v=y(()=>$t(m())),T=y(()=>m()!=="sm"),w=y(()=>oe(m())),Y=y(()=>t(v)/2),J=y(()=>t(v)/2);const St={novelty:"Novelty",arousal:"Arousal",reward:"Reward",attention:"Attention"};let N=y(()=>ne({novelty:C.novelty,arousal:C.arousal,reward:C.reward,attention:C.attention}));function H(d,l){const r=d*t(w);return[t(Y)+Math.cos(l)*r,t(J)+Math.sin(l)*r]}const st=[.25,.5,.75,1];function nt(d){return gt.map(({angle:r})=>H(d,r)).map((r,c)=>`${c===0?"M":"L"}${r[0].toFixed(2)},${r[1].toFixed(2)}`).join(" ")+" Z"}let $=q(0);Pt(()=>{const l=performance.now();let r=0;const c=b=>{const g=Math.min(1,(b-l)/600);F($,1-Math.pow(1-g,3)),g<1&&(r=requestAnimationFrame(c))};return r=requestAnimationFrame(c),()=>cancelAnimationFrame(r)});let ot=y(()=>{const d=t($);return gt.map(({key:r,angle:c})=>H(t(N)[r]*d,c)).map((r,c)=>`${c===0?"M":"L"}${r[0].toFixed(2)},${r[1].toFixed(2)}`).join(" ")+" Z"});function _t(d){const l=t(w)+(m()==="lg"?18:12),r=t(Y)+Math.cos(d)*l,c=t(J)+Math.sin(d)*l;let b="middle";return Math.abs(Math.cos(d))>.5&&(b=Math.cos(d)>0?"start":"end"),{x:r,y:c,anchor:b}}var P=ve(),it=i(P);V(it,17,()=>st,rt,(d,l)=>{var r=ie();S(c=>{p(r,"d",c),p(r,"stroke-opacity",t(l)===1?.45:.18),p(r,"stroke-width",t(l)===1?1:.75)},[()=>nt(t(l))]),x(d,r)});var ht=o(it);V(ht,17,()=>gt,rt,(d,l)=>{const r=y(()=>{const[b,g]=H(1,t(l).angle);return{x:b,y:g}});var c=le();S(()=>{p(c,"x1",t(Y)),p(c,"y1",t(J)),p(c,"x2",t(r).x),p(c,"y2",t(r).y)}),x(d,c)});var W=o(ht),Q=o(W);{var wt=d=>{var l=Nt(),r=U(l);V(r,17,()=>gt,rt,(c,b)=>{const g=y(()=>{const[I,dt]=H(t(N)[t(b).key]*t($),t(b).angle);return{px:I,py:dt}});var j=de();S(()=>{p(j,"cx",t(g).px),p(j,"cy",t(g).py),p(j,"r",m()==="lg"?3:2.25)}),x(c,j)}),x(d,l)};R(Q,d=>{m()!=="sm"&&d(wt)})}var lt=o(Q);{var tt=d=>{var l=Nt(),r=U(l);V(r,17,()=>gt,rt,(c,b)=>{const g=y(()=>_t(t(b).angle));var j=ce(),I=U(j),dt=i(I);n(I);var L=o(I),ct=i(L,!0);n(L),S(At=>{p(I,"x",t(g).x),p(I,"y",t(g).y),p(I,"text-anchor",t(g).anchor),p(I,"font-size",m()==="lg"?12:10),_(dt,`${At??""}%`),p(L,"x",t(g).x),p(L,"y",t(g).y+(m()==="lg"?14:11)),p(L,"text-anchor",t(g).anchor),p(L,"font-size",m()==="lg"?10:8.5),_(ct,St[t(b).key])},[()=>(t(N)[t(b).key]*100).toFixed(0)]),x(c,j)}),x(d,l)};R(lt,d=>{t(T)&&d(tt)})}n(P),S((d,l,r,c)=>{p(P,"width",t(v)),p(P,"height",t(v)),p(P,"viewBox",`0 0 ${t(v)??""} ${t(v)??""}`),p(P,"aria-label",`Importance radar: novelty ${d??""}%, arousal ${l??""}%, reward ${r??""}%, attention ${c??""}%`),p(W,"d",t(ot)),p(W,"stroke-width",m()==="sm"?1:1.5)},[()=>(t(N).novelty*100).toFixed(0),()=>(t(N).arousal*100).toFixed(0),()=>(t(N).reward*100).toFixed(0),()=>(t(N).attention*100).toFixed(0)]),x(a,P),Tt()}var pe=h(' '),xe=h('Driven by ',1),me=h('

      ✓ Save

      '),ue=h('Weakest channel: ',1),fe=h('
      ⨯ Skip

      '),ge=h('
      Composite
      %
      ',1),ye=h(`
      ◫

      Type some content above to score its importance.

      Composite = 0.25·novelty + 0.30·arousal + 0.25·reward + 0.20·attention. Threshold for save: 60%.

      `),_e=h('
      '),he=h('
      '),we=h('

      No memories yet.

      '),be=h('· ',1),ke=h(' '),Me=h('
      '),Se=h(``),Ae=h('
      '),Ce=h(`

      Importance Radar

      4-channel importance model: Novelty · Arousal · Reward · Attention

      Test Importance

      Paste any content below. Vestige scores it across 4 channels and decides whether it is worth saving.

      Why Pro exists

      Two plans. One promise: agent memory you can depend on.

      Always-on answers

      The support bot handles the first wave.

      This is the first support layer: instant onboarding answers before anyone has to write an email. It can run locally from the FAQ now and call a hosted support endpoint later.

      Onboarding bot

      May to June

      The plan is simple.

      1. May Get Vestige into every MCP, Claude Code, Cursor, local AI, Rust, and self-hosted channel that cares about agent memory.
      2. June Invite the first Solo Pro and Team Pro users into sync, backups, shared memory, PostgreSQL-backed deployments, and bot-assisted support.
      3. After Use paid feedback to turn Vestige from a beloved local tool into durable agent-memory infrastructure.
      `);function Ft(Be,Ee){ct(Ee,!0);let q,G=p(""),j=p(""),I=p("solo"),J=p("sync"),x=p(""),H=p(""),y=p("idle"),_=p(""),S=p(""),T=p(!1),C=p(mt([{role:"bot",content:"Ask me about installing Vestige, whether heavy models are required, Solo vs Team Pro, sync, pricing, or what happens after you join the June list."}]));const Fe=[{value:"Local",label:"SQLite memory, no hosted memory service"},{value:"MCP",label:"Claude Code, Cursor, Cline, Codex, Goose"},{value:"June",label:"Pro sync, backup, team memory early access"}],De=[{name:"Solo Pro",accent:"#22c55e",copy:"Multi-device sync, encrypted backups, managed updates, and a cleaner memory dashboard for developers living inside AI coding agents."},{name:"Team Pro",accent:"#06b6d4",copy:"Shared project memory, admin review, audit trails, PostgreSQL-backed deployments, and async support for engineering teams."}],Oe=["Private by default","Sync without lock-in","Team memory controls","Bot-assisted support"],ze=[{label:"Install",prompt:"How do I install Vestige and connect it to Claude Code?"},{label:"No 20GB?",prompt:"Do I need the Sanhedrin model or 20GB of RAM?"},{label:"Solo vs Team",prompt:"Should I choose Solo Pro or Team Pro?"},{label:"Sync",prompt:"How will Pro sync and backups work?"},{label:"Pricing",prompt:"How much will Vestige Pro cost?"},{label:"Human help",prompt:"When does a human get involved?"}];it(()=>{const t=q.getContext("2d");if(!t)return;const e=t;let r=0,i=0,m=0;const d=Array.from({length:62},(b,w)=>({x:Math.random(),y:Math.random(),vx:(Math.random()-.5)*16e-5,vy:(Math.random()-.5)*16e-5,phase:Math.random()*Math.PI*2,kind:w%5}));function M(){const b=Math.min(window.devicePixelRatio||1,2);i=window.innerWidth,m=window.innerHeight,q.width=Math.floor(i*b),q.height=Math.floor(m*b),q.style.width=`${i}px`,q.style.height=`${m}px`,e.setTransform(b,0,0,b,0,0)}function Me(b){e.clearRect(0,0,i,m);const w=e.createLinearGradient(0,0,i,m);w.addColorStop(0,"#07100f"),w.addColorStop(.45,"#0b1221"),w.addColorStop(1,"#15100a"),e.fillStyle=w,e.fillRect(0,0,i,m),e.strokeStyle="rgba(148, 163, 184, 0.08)",e.lineWidth=1;for(let n=0;n.96)&&(n.vx*=-1),(n.y<.06||n.y>.94)&&(n.vy*=-1);for(let n=0;n{cancelAnimationFrame(r),window.removeEventListener("resize",M)}});function Ne(){const t=["## Vestige Pro waitlist","",`Plan: ${a(I)}`,`Priority: ${a(J)}`,a(x).trim()?`Use case: ${a(x).trim()}`:"Use case:","","Please do not include private email addresses in this public issue."].join(` `);return`https://github.com/samvallad33/vestige/issues/new?title=${encodeURIComponent("Vestige Pro waitlist")}&body=${encodeURIComponent(t)}`}async function Ye(t){if(t.preventDefault(),c(y,"submitting"),c(_,""),a(H).trim()){c(y,"success"),c(_,"You are on the list.");return}if(!a(j).includes("@")){c(y,"error"),c(_,"Enter an email so the early-access invite can reach you.");return}a(G).trim(),a(j).trim(),a(I),a(J),a(x).trim(),new Date().toISOString();{c(y,"success"),c(_,"Email capture is ready for an endpoint. Opening the GitHub waitlist fallback with your email omitted."),window.open(Ne(),"_blank","noopener,noreferrer");return}}function Ke(t){const e=t.toLowerCase();return/(install|setup|onboard|claude|cursor|cline|codex|connect)/.test(e)?["Start with the open-source install:","1. `npm install -g vestige-mcp-server@latest`","2. Claude Code: `claude mcp add vestige vestige-mcp -s user`","3. Codex: `codex mcp add vestige -- vestige-mcp`","Then test it by asking your agent to remember a preference, opening a fresh session, and asking for that preference back."].join(` diff --git a/apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.br b/apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.br new file mode 100644 index 0000000000000000000000000000000000000000..183b2394f20c97ec596d33695c00e006ef4e1446 GIT binary patch literal 5512 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 KbJ`P(HNscUd#%U- literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.gz b/apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..ba4845c0e5a6fa146ad40071b4a5f9341ef268cd GIT binary patch literal 6454 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 diff --git a/apps/dashboard/build/_app/immutable/nodes/3.De3LPrRR.js b/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js similarity index 56% rename from apps/dashboard/build/_app/immutable/nodes/3.De3LPrRR.js rename to apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js index 1e3af41..28965de 100644 --- a/apps/dashboard/build/_app/immutable/nodes/3.De3LPrRR.js +++ b/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js @@ -1 +1 @@ -import"../chunks/Bzak7iHL.js";import{i as p}from"../chunks/BUoSzNdg.js";import{o as r}from"../chunks/GG5zm9kr.js";import{p as t,a}from"../chunks/CpWkWWOo.js";import{g as m}from"../chunks/BTwePnbx.js";function g(i,o){t(o,!1),r(()=>m("/graph",{replaceState:!0})),p(),a()}export{g as component}; +import"../chunks/Bzak7iHL.js";import{i as p}from"../chunks/BUoSzNdg.js";import{o as r}from"../chunks/GG5zm9kr.js";import{p as t,a}from"../chunks/CpWkWWOo.js";import{g as m}from"../chunks/D-gDZzN6.js";function g(i,o){t(o,!1),r(()=>m("/graph",{replaceState:!0})),p(),a()}export{g as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.br b/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.br new file mode 100644 index 0000000000000000000000000000000000000000..840c5ed9ce2d6e1e2301267de55de990d59e264d GIT binary patch literal 165 zcmV;W09yYWBmp30aZZ1uwyN}mr-3t|yt!Kwje|@r= TVO%r;7b(CQ7iNli$ZU`U3Gqku literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.gz b/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..3482e9c2dbfb793264218c55ac114fa53b182b71 GIT binary patch literal 198 zcmV;%06G63iwFP!000026J5*WxHVZ1%ZKqt0e&d07igW AS^xk5 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js.br b/apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js.br deleted file mode 100644 index 788a8c45be42d875b1aa7caa247159c4ad224595..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4438 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 diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js.gz b/apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js.gz deleted file mode 100644 index baf0e0059c6bb35930644c6ea065e0769904b8b4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4976 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 diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js b/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js similarity index 98% rename from apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js rename to apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js index 7d60bca..eb053c8 100644 --- a/apps/dashboard/build/_app/immutable/nodes/4.DJCab_le.js +++ b/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js @@ -1,4 +1,4 @@ -import"../chunks/Bzak7iHL.js";import{o as we,a as Ne}from"../chunks/GG5zm9kr.js";import{p as Me,s as A,c as le,aB as ve,e as y,d as p,t as L,g as e,f as Ee,u as de,r as v,a as Se,h as d,n as me}from"../chunks/CpWkWWOo.js";import{s as K,d as Ie,a as xe}from"../chunks/BlVfL1ME.js";import{i as ue}from"../chunks/B4yTwGkE.js";import{a as E,c as Fe,b as oe,f as X}from"../chunks/CHOnp4oo.js";import{s as o,r as ge}from"../chunks/A7po6GxK.js";import{b as Ge,a as Pe}from"../chunks/sZcqyNBA.js";import{a as he}from"../chunks/DNjM5a-l.js";import{e as ke}from"../chunks/MAY1QfFZ.js";import{e as fe,i as ye}from"../chunks/CGEBXrjl.js";import{p as W}from"../chunks/V6gjw5Ec.js";import{N as Ce}from"../chunks/DzfRjky4.js";const Re=.93,Te=.05,be="#8B95A5",Le="#818cf8",Oe=140,pe=8,De=4,Ke=12;function je(s){return!Number.isFinite(s)||s<=0?0:s*Re}function Ue(s){return Number.isFinite(s)?s>=Te:!1}function Ae(s){return!Number.isFinite(s)||stypeof b=="string");M.length!==0&&u.push({source_id:N.source_id,target_ids:M})}return u.reverse()}var Qe=oe(''),We=oe(''),Xe=oe(' '),Je=oe(''),Ze=oe('');function $e(s,f){Me(f,!0);let u=W(f,"width",3,900),x=W(f,"height",3,560),N=W(f,"source",3,null),M=W(f,"neighbours",19,()=>[]),b=W(f,"liveBurstKey",3,0),S=W(f,"liveBurst",3,null);const F=22,J=14;let B=A(le([])),G=A(le([])),T=A(le([])),U=0,O=null,ne=null,Z=0;function $(n,t,c,_){U+=1;const i=U,l=b()>0&&e(B).length>0?40:0,m=c+(Math.random()-.5)*l,g=_+(Math.random()-.5)*l;d(T,[...e(T),{burstId:i,x:m,y:g,radius:F,opacity:.75},{burstId:i,x:m,y:g,radius:F,opacity:.5}],!0);const V={id:`${n.id}::${i}`,label:n.label,nodeType:"source",x:m,y:g,activation:1,isSource:!0,sourceBurstId:i},H=[],k=[],C=U*.37%(Math.PI*2),re=qe(m,g,t.length,C);t.forEach((D,ie)=>{const se=re[ie];se&&(H.push({id:`${D.id}::${i}`,label:D.label,nodeType:D.nodeType,x:se.x,y:se.y,activation:Ye(ie,t.length),isSource:!1,sourceBurstId:i}),k.push({burstId:i,sourceNodeId:V.id,targetNodeId:`${D.id}::${i}`,drawProgress:0,staggerDelay:ze(ie),framesElapsed:0}))}),d(B,[...e(B),V,...H],!0),d(G,[...e(G),...k],!0)}function q(){let n=[];for(const i of e(B)){const l=je(i.activation);Ue(l)&&n.push({...i,activation:l})}d(B,n,!0);const t=new Set(n.map(i=>i.id));let c=[];for(const i of e(G)){if(!t.has(i.sourceNodeId)||!t.has(i.targetNodeId))continue;const l=i.framesElapsed+1;let m=i.drawProgress;l>=i.staggerDelay&&(m=Math.min(1,m+1/15)),c.push({...i,framesElapsed:l,drawProgress:m})}d(G,c,!0);let _=[];for(const i of e(T)){const l=i.radius+6,m=i.opacity*.96;m<.02||l>Math.max(u(),x())||_.push({...i,radius:l,opacity:m})}d(T,_,!0),O=requestAnimationFrame(q)}function Y(){d(B,[],!0),d(G,[],!0),d(T,[],!0)}ve(()=>{if(!N())return;const n=N().id;n!==ne&&(ne=n,Y(),$(N(),M(),u()/2,x()/2))}),ve(()=>{if(!S()||b()===0||b()===Z)return;Z=b();const n=(Math.random()-.5)*120,t=(Math.random()-.5)*120;$(S().source,S().neighbours,u()/2+n,x()/2+t)}),we(()=>{O=requestAnimationFrame(q)}),Ne(()=>{O!==null&&cancelAnimationFrame(O)});function ce(n,t){return Ve(n,t)}function ee(n){const t=e(B).find(l=>l.id===n.sourceNodeId),c=e(B).find(l=>l.id===n.targetNodeId);if(!t||!c)return null;const _=t.x+(c.x-t.x)*n.drawProgress,i=t.y+(c.y-t.y)*n.drawProgress;return{x1:t.x,y1:t.y,x2:_,y2:i}}var P=Ze(),te=y(p(P));fe(te,17,()=>e(T),ye,(n,t)=>{var c=Qe();L(()=>{o(c,"cx",e(t).x),o(c,"cy",e(t).y),o(c,"r",e(t).radius),o(c,"opacity",e(t).opacity)}),E(n,c)});var j=y(te);fe(j,17,()=>e(G),ye,(n,t)=>{const c=de(()=>ee(e(t)));var _=Fe(),i=Ee(_);{var l=m=>{var g=We();L(()=>{o(g,"x1",e(c).x1),o(g,"y1",e(c).y1),o(g,"x2",e(c).x2),o(g,"y2",e(c).y2),o(g,"opacity",.35*e(t).drawProgress)}),E(m,g)};ue(i,m=>{e(c)&&m(l)})}E(n,_)});var z=y(j);fe(z,17,()=>e(B),n=>n.id,(n,t)=>{const c=de(()=>ce(e(t).nodeType,e(t).isSource)),_=de(()=>e(t).isSource?F*(.7+.3*e(t).activation):J*(.5+.8*e(t).activation));var i=Je(),l=p(i),m=y(l),g=y(m),V=y(g);{var H=k=>{var C=Xe(),re=p(C,!0);v(C),L(D=>{o(C,"x",e(t).x),o(C,"y",e(t).y+e(_)+18),o(C,"opacity",.9*e(t).activation),K(re,D)},[()=>e(t).label.length>40?e(t).label.slice(0,40)+"…":e(t).label]),E(k,C)};ue(V,k=>{e(t).isSource&&e(t).label&&k(H)})}v(i),L(k=>{o(i,"opacity",k),o(l,"cx",e(t).x),o(l,"cy",e(t).y),o(l,"r",e(_)*1.9),o(l,"fill",e(c)),o(l,"opacity",.18*e(t).activation),o(m,"cx",e(t).x),o(m,"cy",e(t).y),o(m,"r",e(_)),o(m,"fill",e(c)),o(g,"cx",e(t).x-e(_)*.3),o(g,"cy",e(t).y-e(_)*.3),o(g,"r",e(_)*.35),o(g,"opacity",.35*e(t).activation)},[()=>Math.min(1,e(t).activation*1.25)]),E(n,i)}),v(P),L(()=>{o(P,"width",u()),o(P,"height",x()),o(P,"viewBox",`0 0 ${u()??""} ${x()??""}`)}),E(s,P),Se()}var et=X('
      ◎

      Computing activation...

      '),tt=X('
      ⚠

      Activation failed

      '),rt=X(`
      ◬

      No matching memory

      Nothing in the graph matches . Try a broader +import"../chunks/Bzak7iHL.js";import{o as we,a as Ne}from"../chunks/GG5zm9kr.js";import{p as Me,s as A,c as le,aB as ve,e as y,d as p,t as L,g as e,f as Ee,u as de,r as v,a as Se,h as d,n as me}from"../chunks/CpWkWWOo.js";import{s as K,d as Ie,a as xe}from"../chunks/BlVfL1ME.js";import{i as ue}from"../chunks/B4yTwGkE.js";import{a as E,c as Fe,b as oe,f as X}from"../chunks/CHOnp4oo.js";import{s as o,r as ge}from"../chunks/A7po6GxK.js";import{b as Ge,a as Pe}from"../chunks/sZcqyNBA.js";import{a as he}from"../chunks/554JRhq6.js";import{e as ke}from"../chunks/MAY1QfFZ.js";import{e as fe,i as ye}from"../chunks/CGEBXrjl.js";import{p as W}from"../chunks/V6gjw5Ec.js";import{N as Ce}from"../chunks/CcUbQ_Wl.js";const Re=.93,Te=.05,be="#8B95A5",Le="#818cf8",Oe=140,pe=8,De=4,Ke=12;function je(s){return!Number.isFinite(s)||s<=0?0:s*Re}function Ue(s){return Number.isFinite(s)?s>=Te:!1}function Ae(s){return!Number.isFinite(s)||stypeof b=="string");M.length!==0&&u.push({source_id:N.source_id,target_ids:M})}return u.reverse()}var Qe=oe(''),We=oe(''),Xe=oe(' '),Je=oe(''),Ze=oe('');function $e(s,f){Me(f,!0);let u=W(f,"width",3,900),x=W(f,"height",3,560),N=W(f,"source",3,null),M=W(f,"neighbours",19,()=>[]),b=W(f,"liveBurstKey",3,0),S=W(f,"liveBurst",3,null);const F=22,J=14;let B=A(le([])),G=A(le([])),T=A(le([])),U=0,O=null,ne=null,Z=0;function $(n,t,c,_){U+=1;const i=U,l=b()>0&&e(B).length>0?40:0,m=c+(Math.random()-.5)*l,g=_+(Math.random()-.5)*l;d(T,[...e(T),{burstId:i,x:m,y:g,radius:F,opacity:.75},{burstId:i,x:m,y:g,radius:F,opacity:.5}],!0);const V={id:`${n.id}::${i}`,label:n.label,nodeType:"source",x:m,y:g,activation:1,isSource:!0,sourceBurstId:i},H=[],k=[],C=U*.37%(Math.PI*2),re=qe(m,g,t.length,C);t.forEach((D,ie)=>{const se=re[ie];se&&(H.push({id:`${D.id}::${i}`,label:D.label,nodeType:D.nodeType,x:se.x,y:se.y,activation:Ye(ie,t.length),isSource:!1,sourceBurstId:i}),k.push({burstId:i,sourceNodeId:V.id,targetNodeId:`${D.id}::${i}`,drawProgress:0,staggerDelay:ze(ie),framesElapsed:0}))}),d(B,[...e(B),V,...H],!0),d(G,[...e(G),...k],!0)}function q(){let n=[];for(const i of e(B)){const l=je(i.activation);Ue(l)&&n.push({...i,activation:l})}d(B,n,!0);const t=new Set(n.map(i=>i.id));let c=[];for(const i of e(G)){if(!t.has(i.sourceNodeId)||!t.has(i.targetNodeId))continue;const l=i.framesElapsed+1;let m=i.drawProgress;l>=i.staggerDelay&&(m=Math.min(1,m+1/15)),c.push({...i,framesElapsed:l,drawProgress:m})}d(G,c,!0);let _=[];for(const i of e(T)){const l=i.radius+6,m=i.opacity*.96;m<.02||l>Math.max(u(),x())||_.push({...i,radius:l,opacity:m})}d(T,_,!0),O=requestAnimationFrame(q)}function Y(){d(B,[],!0),d(G,[],!0),d(T,[],!0)}ve(()=>{if(!N())return;const n=N().id;n!==ne&&(ne=n,Y(),$(N(),M(),u()/2,x()/2))}),ve(()=>{if(!S()||b()===0||b()===Z)return;Z=b();const n=(Math.random()-.5)*120,t=(Math.random()-.5)*120;$(S().source,S().neighbours,u()/2+n,x()/2+t)}),we(()=>{O=requestAnimationFrame(q)}),Ne(()=>{O!==null&&cancelAnimationFrame(O)});function ce(n,t){return Ve(n,t)}function ee(n){const t=e(B).find(l=>l.id===n.sourceNodeId),c=e(B).find(l=>l.id===n.targetNodeId);if(!t||!c)return null;const _=t.x+(c.x-t.x)*n.drawProgress,i=t.y+(c.y-t.y)*n.drawProgress;return{x1:t.x,y1:t.y,x2:_,y2:i}}var P=Ze(),te=y(p(P));fe(te,17,()=>e(T),ye,(n,t)=>{var c=Qe();L(()=>{o(c,"cx",e(t).x),o(c,"cy",e(t).y),o(c,"r",e(t).radius),o(c,"opacity",e(t).opacity)}),E(n,c)});var j=y(te);fe(j,17,()=>e(G),ye,(n,t)=>{const c=de(()=>ee(e(t)));var _=Fe(),i=Ee(_);{var l=m=>{var g=We();L(()=>{o(g,"x1",e(c).x1),o(g,"y1",e(c).y1),o(g,"x2",e(c).x2),o(g,"y2",e(c).y2),o(g,"opacity",.35*e(t).drawProgress)}),E(m,g)};ue(i,m=>{e(c)&&m(l)})}E(n,_)});var z=y(j);fe(z,17,()=>e(B),n=>n.id,(n,t)=>{const c=de(()=>ce(e(t).nodeType,e(t).isSource)),_=de(()=>e(t).isSource?F*(.7+.3*e(t).activation):J*(.5+.8*e(t).activation));var i=Je(),l=p(i),m=y(l),g=y(m),V=y(g);{var H=k=>{var C=Xe(),re=p(C,!0);v(C),L(D=>{o(C,"x",e(t).x),o(C,"y",e(t).y+e(_)+18),o(C,"opacity",.9*e(t).activation),K(re,D)},[()=>e(t).label.length>40?e(t).label.slice(0,40)+"…":e(t).label]),E(k,C)};ue(V,k=>{e(t).isSource&&e(t).label&&k(H)})}v(i),L(k=>{o(i,"opacity",k),o(l,"cx",e(t).x),o(l,"cy",e(t).y),o(l,"r",e(_)*1.9),o(l,"fill",e(c)),o(l,"opacity",.18*e(t).activation),o(m,"cx",e(t).x),o(m,"cy",e(t).y),o(m,"r",e(_)),o(m,"fill",e(c)),o(g,"cx",e(t).x-e(_)*.3),o(g,"cy",e(t).y-e(_)*.3),o(g,"r",e(_)*.35),o(g,"opacity",.35*e(t).activation)},[()=>Math.min(1,e(t).activation*1.25)]),E(n,i)}),v(P),L(()=>{o(P,"width",u()),o(P,"height",x()),o(P,"viewBox",`0 0 ${u()??""} ${x()??""}`)}),E(s,P),Se()}var et=X('

      ◎

      Computing activation...

      '),tt=X('
      ⚠

      Activation failed

      '),rt=X(`
      ◬

      No matching memory

      Nothing in the graph matches . Try a broader query or switch on live mode to watch the engine fire its own bursts.

      `),it=X(`
      ◎

      Waiting for activation

      Seed a burst with the search bar above, or enable live mode to overlay bursts from the cognitive engine as they happen.

      `),st=X('
      Seed

      '),at=X(`

      Spreading Activation

      Collins & Loftus 1975 — activation spreads from a seed memory to diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.br b/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.br new file mode 100644 index 0000000000000000000000000000000000000000..715e2abd6662c90c4ac6f2c5543d7d6028c5d80a GIT binary patch literal 4437 zcmV-b5vuMRf-eA^1$L7&ES3qsh;j5JhQ%10j*w(_vbE|x`+2Rb<;omP0x~yFiN|qO z7ahVCNe~m#23v5*0c$|lwkV47znWV2xtv-YRPT%5Jt4RJq}defzL^zIS{y(HE!(UI zh)QQg>DoL}dp!o)5!78qkR3k&N)u$s{hzA3-a&+9C*7q@d3zm3nNBkGWz5UOOyr+}m9=fhS#yw2{tl_07M{y`Ngh?WUIXl>h8q6O?~| z^fr7y&+<2edrfhE9Bql#`>)q`->I?Xd;LTeUp!~=8@|oIx~=E@@dq8T!B~WI%Ph+-f+$bi zReoQT$nev7 zO!QWZA3mDqHx3u8ENYvsc$m<$Z0co>o+gW~j~8()7(U>AH@IL-;f#Jc+gf@qV`{i@ z^9X>9%d<4ZhG8WA>1Ga5#`C39H;udKdX8hj4Uc$qf7&O)CDtws;2k94L_Ci+hP6VG zWM?TI2i7nd-&Yl>la{A}$c?fe{*cg&Kg!OCrTyN*kc>7R#RVMWMj$*~W?7H9&)X%O zzW>E&KT#I@wtg3X)_;9v-@Q3NQdK0ifbWA2&-jvA&}fYc*JDW3W{QpzS?#5^k1AE5 zyRRHa+dCB9eQl0+pbK9rO@B*zrLKJjc%^R0z%12JTl`Jhm7`r%zh?WaoQlJcOzWeV zrHZWV?3^rQ;_ieKyqkN(KAX`D`wTo5n{2@axb_5QdMf=8#py#!_k+2UAYVC0bP&bXi&+0>S zrq=v{aKRM5>;p9aVa1JigdEuxLzthf7rxMoV^oF1j4Y)#n;GG~3TLz5&4@2wjGvJW z{b1cHoQVX8%^r2eJ8U$H0$NO6{zHcn@no>u++#04GttbK=r;X5p28z7wSOrCGV(WnPma?s{ z)BxM3w7h0jMEVY0rm1WCak$MzX}=EdyQr2>TXyfSkyt-8-PS{ul#))QBs3XxZU7}N;Wy;9Ri+oi(dr>dYVki_sg(Ows3 zSd_vebSvkgFijkQ=@q96xTCI@&6^iT!H3>T^~+vVehO#rrvt+J%L&!DM$6{roDty? z)^G2!1uC3hMCfn#-)yoaV9szxJ=6NZCjunA2Qn`lyQeqX+JSMsH{sSPedv`AYav{# zOum<$)(uSnMqGC(f8dE>OGZ7WXSr${VB<}kO+##qcRzuz{X_7JxXR4S96Q<8UZ&i0 z>O#}wZg9tu?RVrO@IT>>@1)JI)%Prsc1gdg?__!We1p=$EUhc=_rvX0lf-jk&`QKR zG6a~1Dmh&o`(J{z%ff)?7t)pe+uUvpYcoJo^2`DkZvyk!3-s;kZL=ap!+6pf_o{cC z$jW9j@m+<;^*hm@CbX{A2emaNW)7WVow6u5cXgG8lJau3rA*ZNqd)|cX-O;&V%Xv ztbsgx4f0~K?_)zAIP9H;E2s82U|qYB(P{4a+^JNefVDWiGFQPXK9?PmrEl~N7CZ?$g;*lT!o(t>ki$*QFKWK1l;Z=i3f?Zo zTn^X-&+mQ(cJ0MuMTo+pG7Rn6F1_zBm?y}B@&#Fw2@r8r7nx%UL7baiSfUVc#^q(U zK9Z(XU?C|JAxqZRI}Z)NO<>jI}^%L0EXGjNK+TZ}m7W#EZ%TG{z~77A5g)AKDvbJckLo zyRjXxA@^C9vH6$o2&}VE;z5TRoXwNo(^(gs0`=uBudVHQaS1<7%+s+W&VX z6lwZ{0&5=QJ+e0BkMWz+rPf~>SR#s+CXZX!E5&GQ{va9nU{Dim;*QH8rK!FzP}B2b zm!h_+0yZrE-+z7RGjA+EJRN2=0qt=NbiAK5D>`l8zVZ;uq{5#ZkrX~r5sc1&%j(To z1~l7hvBqZ~{s`TU(d!uggA+i@0S?I^CP&~9E@)PfasY)Rx^ejv*RscR524j{1x@Tf zI2y)0I$nA$x{_Lq1AbJPX@c5jO}`nhl;Xg3)KO31p0G$Eqz1MW_i@8ZbM~qdnD$*lXj%%rsB5a42eXJg(OqpP0Z5+JsLT- z4x;t}jd&Rc{)uf7$EmFI{l?8Xnt_!FqaA=D+>;s$&H6|hr4}W{QT#Q2*yjk|Pol9}Ai^Mlup&+ETupt)HI&t-Igm=8=98u{Gb3u2R{NF%_W`?qxKL-$hE<&!c ziW8BDzB~jbRKo&Nrgn;1)k{GHtFzT4061w1C>$9cS=!h#J-pGInCFd25c-!;?x+@& zZ2k{Ouc!)I7<55G>1?Ev%d_|-9n)0gAhl4xgR(Lnq{?BdY~F0!)gVc#n`rZA3`7n| zw?`-$h8A=XVbS)wjgZgLjCSx(QP*V4=VuVX;%-JtT9)mEnxVC9<%NufMT-uZk@*WL z|j0A zRtq|L<9%f{5ZYS2Ab`p8;BE-j6lp9I+cc}H=st|iGjfNVnrZZaHW5omqa;`Rc~bE8`N4Nu9ga%>3M@n9*hM8#SGalyH5g`S835^ z;5u3Vi1xG8Yon_B#K7?CsK!#$KTjrx6>AuS{G_!FF zT31l>gbK80e2POab^qI34}++lTL$>3Jl5SG-gjiWJ)483%^8wkzXi8ulY|O*BCT^# zmYUm>bf`(%?1ly!s(L|cXUgpi6V>-|V+jsCg^r}di}LLYZLkX>=s)V1o zTfWvh>23FY8%&m`I&xtCNCrPq_^S{%DNd^MxH;O-fh?tu-b@~nK8ylK^$gt=kM*%7 z8U7ZWA*6wiqB_NevEkGSL2)i!UP8%Zz1ccCg6}@xTgz&fTQSbyE2QH*m`KBT3An?! zJaitQhCV+xvlKz-GMvyIs7sD+kwmZN8=C0fxJOB#kb$b{tzZ>d2!o_k$;*H-WP zupC_Iip1r13nXJDe^+w@khM=*`-;@OT|`44?V%zZj#t4j-lOziE=VfwHH5!xI(n|- zS$iV?A}H<|y>?6YfFD=4!D0oPzxg40s zx=0kPdFDMNhwP!=+=4_1KX_p+IIa{U_i8w-O+6hZnC=Uh6AM=<0SP87ET;%8s>n;B z;IUP(oi5t6`3%Icgw`!64|Y;ZUNlH@F*5EEE=Y{V;zRpx-L1q&!mYC%Vdx>ICPK*l z+t-Z4_R6~nD}x$Fz=o5UkR8>YD}UAc?;)fhth4(VYbV#zLQ>h&QB^iH->>OPyi}^u zaxEcNxvSGVgDtB=_~y163ng6G>xAY(;=AZ5@y1-=CAB^LwUpHy14|*MTbrZ~B~{=6 zxviQRM{PHqSib6H@+}hwms@gNFXor3z+$3&r_kaGT7)HDmHA$7BCVT*0d$EIH(%zC zeCe&66;=vG!&ecm2&-gYo*1n|npGMEcLy4U&LHh}mu9lU1LH-m{FSc$x|SB?)e#^6 zqdTP$Ya!8s_*udsgoNQxar=*}u{(<)6w3h1j-p}MpDJ}}7N~N_S$=b%{=v6En$s;_LOQoV#Noad@bKzk3){1MyoX}k!BERd b2f{h-ns&VK)pugyqegR3mc^NN5H0o(n%Sov literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.gz b/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..6cf01ba109d5b61fbf7512c0615bc0a91767d7f9 GIT binary patch literal 4976 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 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js b/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js similarity index 99% rename from apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js rename to apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js index dcfb793..8d4e000 100644 --- a/apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js +++ b/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js @@ -1,4 +1,4 @@ -import"../chunks/Bzak7iHL.js";import{p as qe,d as a,r as t,e as i,g as e,f as he,u as b,t as R,a as Se,n as X,h as de,s as be,W as Ge,aG as Ae}from"../chunks/CpWkWWOo.js";import{s as x,d as Ye,a as pe}from"../chunks/BlVfL1ME.js";import{c as Fe,a as m,f as _,b as Ve,t as Ie}from"../chunks/CHOnp4oo.js";import{i as j}from"../chunks/B4yTwGkE.js";import{e as ge}from"../chunks/CGEBXrjl.js";import{h as We}from"../chunks/C4h_mRt2.js";import{s as A,r as Be,a as Xe}from"../chunks/A7po6GxK.js";import{s as _e}from"../chunks/aVbAZ-t7.js";import{a as ze}from"../chunks/DNjM5a-l.js";import{s as ae}from"../chunks/Cx-f-Pzo.js";import{p as Ue}from"../chunks/V6gjw5Ec.js";import{b as Je}from"../chunks/BdslOLCg.js";const Te=5,je=["Replay","Cross-reference","Strengthen","Prune","Transfer"];function Oe(v){if(!Number.isFinite(v))return 1;const n=Math.floor(v);return n<1?1:n>Te?Te:n}const Ke=.3,Qe=.7;function Ze(v){const n=ye(v);return n>Qe?"high":n1?1:v}function $e(v){return v==null||!Number.isFinite(v)||v<0?"0ms":v<1e3?`${Math.round(v)}ms`:`${(v/1e3).toFixed(2)}s`}function et(v){const n=ye(v);return`${Math.round(n*100)}%`}function tt(v,n=""){return`${n}/memories/${v}`}function st(v,n=2){return!v||v.length===0?[]:v.slice(0,Math.max(0,n))}function at(v,n=2){return v?Math.max(0,v.length-n):0}function rt(v){return v?v.length>8?v.slice(0,8):v:""}var nt=_('

      Episodic hippocampus
      Semantic cortex
      ',1),it=Ve(''),vt=_('
      '),lt=_(''),ot=_('Replaying memories'),ct=_('New connections found: '),dt=_('Strengthened: '),ut=_('Compressed: '),ft=_('Connections persisted: Insights: ',1),mt=_('
      ');function pt(v,n){qe(n,!0);const N=[{num:1,name:"Replay",color:"#818cf8",desc:"Hippocampal replay: tagged memories surface for consolidation."},{num:2,name:"Cross-reference",color:"#a855f7",desc:"Semantic proximity check — new edges discovered across memories."},{num:3,name:"Strengthen",color:"#c084fc",desc:"Co-activated memories strengthen; FSRS stability grows."},{num:4,name:"Prune",color:"#ef4444",desc:"Low-retention redundant memories compressed or released."},{num:5,name:"Transfer",color:"#10b981",desc:"Episodic → semantic consolidation (hippocampus → cortex)."}];let l=b(()=>Oe(n.stage)),f=b(()=>N[e(l)-1]),q=b(()=>{if(!n.dreamResult)return 8;const s=n.dreamResult.memoriesReplayed??8;return Math.max(6,Math.min(12,s))}),re=b(()=>{var r;if(!n.dreamResult)return 5;const s=((r=n.dreamResult.stats)==null?void 0:r.newConnectionsFound)??5;return Math.max(3,Math.min(e(q),s))}),z=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.5);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesStrengthened)??Math.ceil(e(q)*.5);return Math.max(1,Math.min(e(q),s))}),ne=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.25);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesCompressed)??Math.ceil(e(q)*.25);return Math.max(1,Math.min(Math.floor(e(q)/2),s))});function C(s,r=0){const d=Math.sin((s+1)*9301+49297+r*233)*233280;return d-Math.floor(d)}let U=b(()=>{const s=[],r=Math.ceil(Math.sqrt(e(q))),d=Math.ceil(e(q)/r);for(let c=0;c{const s=[],r=e(U).length;for(let d=0;d{var r=nt();X(4),m(s,r)};j(le,s=>{e(l)===5&&s(oe)})}var ee=i(le,2);ge(ee,23,()=>e(L),(s,r)=>s.a+"-"+s.b+"-"+r,(s,r,d)=>{const c=b(()=>e(U)[e(r).a]),p=b(()=>e(U)[e(r).b]);var u=Fe(),k=he(u);{var w=g=>{const M=b(()=>I(e(c))),h=b(()=>F(e(c))),V=b(()=>I(e(p))),ke=b(()=>F(e(p)));var E=it();R(()=>{A(E,"x1",e(M)),A(E,"y1",e(h)),A(E,"x2",e(V)),A(E,"y2",e(ke)),A(E,"stroke",e(f).color),A(E,"stroke-width",e(l)===2?.25:e(l)===3?.35:.2),A(E,"stroke-opacity",e(l)<2?0:e(l)===4?.25:e(l)===5?.15:.6),A(E,"stroke-dasharray",e(l)===2?"1.2 0.8":"none"),ae(E,`--edge-delay: ${e(d)*80}ms`)}),m(g,E)};j(k,g=>{e(c)&&e(p)&&g(w)})}m(s,u)}),t(ee);var S=i(ee,2);ge(S,17,()=>e(U),s=>s.id,(s,r)=>{var d=vt();let c;R((p,u,k,w,g)=>{c=_e(d,1,"memory-card svelte-1cq1ntk",null,c,{"is-pulsing":e(l)===3&&e(r).strengthened,"is-pruning":e(l)===4&&e(r).pruned,"is-transferring":e(l)===5,"semantic-side":e(l)===5&&e(r).transferIsSemantic}),ae(d,` +import"../chunks/Bzak7iHL.js";import{p as qe,d as a,r as t,e as i,g as e,f as he,u as b,t as R,a as Se,n as X,h as de,s as be,W as Ge,aG as Ae}from"../chunks/CpWkWWOo.js";import{s as x,d as Ye,a as pe}from"../chunks/BlVfL1ME.js";import{c as Fe,a as m,f as _,b as Ve,t as Ie}from"../chunks/CHOnp4oo.js";import{i as j}from"../chunks/B4yTwGkE.js";import{e as ge}from"../chunks/CGEBXrjl.js";import{h as We}from"../chunks/C4h_mRt2.js";import{s as A,r as Be,a as Xe}from"../chunks/A7po6GxK.js";import{s as _e}from"../chunks/aVbAZ-t7.js";import{a as ze}from"../chunks/554JRhq6.js";import{s as ae}from"../chunks/Cx-f-Pzo.js";import{p as Ue}from"../chunks/V6gjw5Ec.js";import{b as Je}from"../chunks/DGcYlAAw.js";const Te=5,je=["Replay","Cross-reference","Strengthen","Prune","Transfer"];function Oe(v){if(!Number.isFinite(v))return 1;const n=Math.floor(v);return n<1?1:n>Te?Te:n}const Ke=.3,Qe=.7;function Ze(v){const n=ye(v);return n>Qe?"high":n1?1:v}function $e(v){return v==null||!Number.isFinite(v)||v<0?"0ms":v<1e3?`${Math.round(v)}ms`:`${(v/1e3).toFixed(2)}s`}function et(v){const n=ye(v);return`${Math.round(n*100)}%`}function tt(v,n=""){return`${n}/memories/${v}`}function st(v,n=2){return!v||v.length===0?[]:v.slice(0,Math.max(0,n))}function at(v,n=2){return v?Math.max(0,v.length-n):0}function rt(v){return v?v.length>8?v.slice(0,8):v:""}var nt=_('
      Episodic hippocampus
      Semantic cortex
      ',1),it=Ve(''),vt=_('
      '),lt=_(''),ot=_('Replaying memories'),ct=_('New connections found: '),dt=_('Strengthened: '),ut=_('Compressed: '),ft=_('Connections persisted: Insights: ',1),mt=_('
      ');function pt(v,n){qe(n,!0);const N=[{num:1,name:"Replay",color:"#818cf8",desc:"Hippocampal replay: tagged memories surface for consolidation."},{num:2,name:"Cross-reference",color:"#a855f7",desc:"Semantic proximity check — new edges discovered across memories."},{num:3,name:"Strengthen",color:"#c084fc",desc:"Co-activated memories strengthen; FSRS stability grows."},{num:4,name:"Prune",color:"#ef4444",desc:"Low-retention redundant memories compressed or released."},{num:5,name:"Transfer",color:"#10b981",desc:"Episodic → semantic consolidation (hippocampus → cortex)."}];let l=b(()=>Oe(n.stage)),f=b(()=>N[e(l)-1]),q=b(()=>{if(!n.dreamResult)return 8;const s=n.dreamResult.memoriesReplayed??8;return Math.max(6,Math.min(12,s))}),re=b(()=>{var r;if(!n.dreamResult)return 5;const s=((r=n.dreamResult.stats)==null?void 0:r.newConnectionsFound)??5;return Math.max(3,Math.min(e(q),s))}),z=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.5);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesStrengthened)??Math.ceil(e(q)*.5);return Math.max(1,Math.min(e(q),s))}),ne=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.25);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesCompressed)??Math.ceil(e(q)*.25);return Math.max(1,Math.min(Math.floor(e(q)/2),s))});function C(s,r=0){const d=Math.sin((s+1)*9301+49297+r*233)*233280;return d-Math.floor(d)}let U=b(()=>{const s=[],r=Math.ceil(Math.sqrt(e(q))),d=Math.ceil(e(q)/r);for(let c=0;c{const s=[],r=e(U).length;for(let d=0;d{var r=nt();X(4),m(s,r)};j(le,s=>{e(l)===5&&s(oe)})}var ee=i(le,2);ge(ee,23,()=>e(L),(s,r)=>s.a+"-"+s.b+"-"+r,(s,r,d)=>{const c=b(()=>e(U)[e(r).a]),p=b(()=>e(U)[e(r).b]);var u=Fe(),k=he(u);{var w=g=>{const M=b(()=>I(e(c))),h=b(()=>F(e(c))),V=b(()=>I(e(p))),ke=b(()=>F(e(p)));var E=it();R(()=>{A(E,"x1",e(M)),A(E,"y1",e(h)),A(E,"x2",e(V)),A(E,"y2",e(ke)),A(E,"stroke",e(f).color),A(E,"stroke-width",e(l)===2?.25:e(l)===3?.35:.2),A(E,"stroke-opacity",e(l)<2?0:e(l)===4?.25:e(l)===5?.15:.6),A(E,"stroke-dasharray",e(l)===2?"1.2 0.8":"none"),ae(E,`--edge-delay: ${e(d)*80}ms`)}),m(g,E)};j(k,g=>{e(c)&&e(p)&&g(w)})}m(s,u)}),t(ee);var S=i(ee,2);ge(S,17,()=>e(U),s=>s.id,(s,r)=>{var d=vt();let c;R((p,u,k,w,g)=>{c=_e(d,1,"memory-card svelte-1cq1ntk",null,c,{"is-pulsing":e(l)===3&&e(r).strengthened,"is-pruning":e(l)===4&&e(r).pruned,"is-transferring":e(l)===5,"semantic-side":e(l)===5&&e(r).transferIsSemantic}),ae(d,` left: ${p??""}%; top: ${u??""}%; opacity: ${k??""}; diff --git a/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.br b/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.br new file mode 100644 index 0000000000000000000000000000000000000000..c2dd190e45851c37808788b7a442b8b7ed40b1a7 GIT binary patch literal 5625 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 Tei4@4?gJ$bo0mH%O7H9)Sm*+? literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.gz b/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..b1295da2122839f763decab437564110920843bc GIT binary patch literal 6335 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 BOIrW{ literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js.br b/apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js.br deleted file mode 100644 index 51c72649f25c2709e7db09e2649ab1abc4ed3ddd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5620 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 ON_^^_+(A+L-`)YC>J>Hs diff --git a/apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js.gz b/apps/dashboard/build/_app/immutable/nodes/6.BN-BfASZ.js.gz deleted file mode 100644 index 64972c861b39f32e2b2fdfbc5b9e8aa309464024..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6334 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.92?"near-identical":s>=.8?"strong":"weak"}function ge(s){const i=De(s);return i==="near-identical"?"var(--color-decay)":i==="strong"?"var(--color-warning)":"#fde047"}function Ee(s){const i=De(s);return i==="near-identical"?"Near-identical":i==="strong"?"Strong match":"Weak match"}function Pe(s){return s>.7?"#10b981":s>.4?"#f59e0b":"#ef4444"}function Be(s){if(!s||s.length===0)return null;let i=s[0],d=Number.isFinite(i.retention)?i.retention:-1/0;for(let u=1;ud&&(i=b,d=_)}return i}function Ie(s,i){return s.filter(d=>d.similarity>=i)}function be(s){return s.map(i=>i.id).slice().sort().join("|")}function Oe(s,i=80){if(!s)return"";const d=s.trim().replace(/\s+/g," ");return d.length<=i?d:d.slice(0,i)+"…"}function ye(s){if(!s||typeof s!="string")return"";const i=new Date(s);return Number.isNaN(i.getTime())?"":i.toLocaleDateString(void 0,{year:"numeric",month:"short",day:"numeric"})}function He(s,i=4){return Array.isArray(s)?s.slice(0,i):[]}var Ue=m('WINNER'),We=m(' '),je=m('
      '),Ke=m('

      '),ze=m('
      ');function Ge(s,i){_e(i,!0);let d=K(!1);const u=I(()=>Be(i.memories)),b=I(()=>e(u)?i.memories.filter(x=>x.id!==e(u).id).map(x=>x.id):[]);function _(){i.onMerge&&e(u)&&i.onMerge(e(u).id,e(b))}var A=Le(),V=we(A);{var le=x=>{var X=ze(),O=r(X),Y=r(O),h=r(Y),C=r(h),ee=r(C);n(C);var H=o(C,2),de=r(H,!0);n(H);var U=o(H,2),q=r(U);n(U),n(h);var R=o(h,2),W=r(R);n(R),n(Y);var j=o(Y,2),ce=r(j);n(j),n(O);var L=o(O,2);oe(L,21,()=>i.memories,k=>k.id,(k,c)=>{var D=Ke(),N=r(D),Z=o(N,2),t=r(Z),a=r(t),l=r(a,!0);n(a);var p=o(a,2);{var E=y=>{var T=Ue();v(y,T)};G(p,y=>{e(c).id===e(u).id&&y(E)})}var M=o(p,2);oe(M,17,()=>He(e(c).tags,4),Ae,(y,T)=>{var B=We(),me=r(B,!0);n(B),S(()=>g(me,e(T))),v(y,B)}),n(t);var f=o(t,2),P=r(f,!0);n(f);var ae=o(f,2);{var Q=y=>{var T=je(),B=r(T,!0);n(T),S(me=>g(B,me),[()=>ye(e(c).createdAt)]),v(y,T)},ve=I(()=>ye(e(c).createdAt));G(ae,y=>{e(ve)&&y(Q)})}n(Z);var ne=o(Z,2),$=r(ne),Me=r($);n($);var fe=o($,2),Se=r(fe);n(fe),n(ne),n(D),S((y,T,B)=>{pe(D,1,`group flex items-start gap-3 rounded-xl border border-synapse/5 bg-white/[0.02] p-3 transition-all duration-200 hover:border-synapse/20 hover:bg-white/[0.04] ${e(c).id===e(u).id?"ring-1 ring-recall/30":""}`),re(N,`background: ${(Ze[e(c).nodeType]||"#8B95A5")??""}`),se(N,"title",e(c).nodeType),g(l,e(c).nodeType),pe(f,1,`text-sm text-text leading-relaxed ${e(d)?"whitespace-pre-wrap":""}`),g(P,y),re(Me,`width: ${e(c).retention*100}%; background: ${T??""}`),g(Se,`${B??""}%`)},[()=>e(d)?e(c).content:Oe(e(c).content),()=>Pe(e(c).retention),()=>(e(c).retention*100).toFixed(0)]),v(k,D)}),n(L);var te=o(L,2),J=r(te),F=o(J,2),ue=r(F,!0);n(F);var ie=o(F,2);n(te),n(X),S((k,c,D,N,Z,t,a,l)=>{re(C,`color: ${k??""}`),g(ee,`${c??""}%`),g(de,D),g(q,`· ${i.memories.length??""} memories`),se(R,"aria-valuenow",N),re(W,`width: ${Z??""}%; background: ${t??""}; box-shadow: 0 0 12px ${a??""}66`),pe(j,1,`flex-shrink-0 rounded-full border px-3 py-1 text-xs font-medium ${i.suggestedAction==="merge"?"border-recall/40 bg-recall/10 text-recall":"border-dream-glow/40 bg-dream/10 text-dream-glow"}`),g(ce,`Suggested: ${i.suggestedAction==="merge"?"Merge":"Review"}`),se(J,"title",`Merge all into highest-retention memory (${l??""}%)`),se(F,"aria-expanded",e(d)),g(ue,e(d)?"Collapse":"Review")},[()=>ge(i.similarity),()=>(i.similarity*100).toFixed(1),()=>Ee(i.similarity),()=>Math.round(i.similarity*100),()=>(i.similarity*100).toFixed(1),()=>ge(i.similarity),()=>ge(i.similarity),()=>(e(u).retention*100).toFixed(0)]),z("click",J,_),z("click",F,()=>w(d,!e(d))),z("click",ie,function(...k){var c;(c=i.onDismiss)==null||c.apply(this,k)}),v(x,X)};G(V,x=>{i.memories.length>0&&e(u)&&x(le)})}v(s,A),ke()}Te(["click"]);var Ve=m(' Detecting…',1),Xe=m(' Error',1),Ye=m(' ',1),qe=m(`
      Couldn't detect duplicates
      `),Je=m('
      '),Qe=m('
      '),$e=m('
      ·
      No duplicates found above threshold.
      Memory is clean.
      '),et=m('
      '),tt=m('
      '),it=m('
      '),at=m(`

      Memory Hygiene — Duplicate Detection

      Cosine-similarity clustering over embeddings. Merges reinforce the winner's FSRS state; +import"../chunks/Bzak7iHL.js";import{o as Ce,a as Re}from"../chunks/GG5zm9kr.js";import{p as _e,f as we,g as e,a as ke,u as I,d as r,r as n,e as o,t as S,h as w,s as K,c as xe,n as he}from"../chunks/CpWkWWOo.js";import{d as Te,s as g,a as z}from"../chunks/BlVfL1ME.js";import{i as G}from"../chunks/B4yTwGkE.js";import{e as oe,i as Ae}from"../chunks/CGEBXrjl.js";import{c as Le,a as v,f as m}from"../chunks/CHOnp4oo.js";import{s as se,r as Fe}from"../chunks/A7po6GxK.js";import{b as Ne}from"../chunks/sZcqyNBA.js";import{s as pe}from"../chunks/aVbAZ-t7.js";import{s as re}from"../chunks/Cx-f-Pzo.js";import{N as Ze}from"../chunks/CcUbQ_Wl.js";function De(s){return s>=.92?"near-identical":s>=.8?"strong":"weak"}function ge(s){const i=De(s);return i==="near-identical"?"var(--color-decay)":i==="strong"?"var(--color-warning)":"#fde047"}function Ee(s){const i=De(s);return i==="near-identical"?"Near-identical":i==="strong"?"Strong match":"Weak match"}function Pe(s){return s>.7?"#10b981":s>.4?"#f59e0b":"#ef4444"}function Be(s){if(!s||s.length===0)return null;let i=s[0],d=Number.isFinite(i.retention)?i.retention:-1/0;for(let u=1;ud&&(i=b,d=_)}return i}function Ie(s,i){return s.filter(d=>d.similarity>=i)}function be(s){return s.map(i=>i.id).slice().sort().join("|")}function Oe(s,i=80){if(!s)return"";const d=s.trim().replace(/\s+/g," ");return d.length<=i?d:d.slice(0,i)+"…"}function ye(s){if(!s||typeof s!="string")return"";const i=new Date(s);return Number.isNaN(i.getTime())?"":i.toLocaleDateString(void 0,{year:"numeric",month:"short",day:"numeric"})}function He(s,i=4){return Array.isArray(s)?s.slice(0,i):[]}var Ue=m('WINNER'),We=m(' '),je=m('

      '),Ke=m('

      '),ze=m('
      ');function Ge(s,i){_e(i,!0);let d=K(!1);const u=I(()=>Be(i.memories)),b=I(()=>e(u)?i.memories.filter(x=>x.id!==e(u).id).map(x=>x.id):[]);function _(){i.onMerge&&e(u)&&i.onMerge(e(u).id,e(b))}var A=Le(),V=we(A);{var le=x=>{var X=ze(),O=r(X),Y=r(O),h=r(Y),C=r(h),ee=r(C);n(C);var H=o(C,2),de=r(H,!0);n(H);var U=o(H,2),q=r(U);n(U),n(h);var R=o(h,2),W=r(R);n(R),n(Y);var j=o(Y,2),ce=r(j);n(j),n(O);var L=o(O,2);oe(L,21,()=>i.memories,k=>k.id,(k,c)=>{var D=Ke(),N=r(D),Z=o(N,2),t=r(Z),a=r(t),l=r(a,!0);n(a);var p=o(a,2);{var E=y=>{var T=Ue();v(y,T)};G(p,y=>{e(c).id===e(u).id&&y(E)})}var M=o(p,2);oe(M,17,()=>He(e(c).tags,4),Ae,(y,T)=>{var B=We(),me=r(B,!0);n(B),S(()=>g(me,e(T))),v(y,B)}),n(t);var f=o(t,2),P=r(f,!0);n(f);var ae=o(f,2);{var Q=y=>{var T=je(),B=r(T,!0);n(T),S(me=>g(B,me),[()=>ye(e(c).createdAt)]),v(y,T)},ve=I(()=>ye(e(c).createdAt));G(ae,y=>{e(ve)&&y(Q)})}n(Z);var ne=o(Z,2),$=r(ne),Me=r($);n($);var fe=o($,2),Se=r(fe);n(fe),n(ne),n(D),S((y,T,B)=>{pe(D,1,`group flex items-start gap-3 rounded-xl border border-synapse/5 bg-white/[0.02] p-3 transition-all duration-200 hover:border-synapse/20 hover:bg-white/[0.04] ${e(c).id===e(u).id?"ring-1 ring-recall/30":""}`),re(N,`background: ${(Ze[e(c).nodeType]||"#8B95A5")??""}`),se(N,"title",e(c).nodeType),g(l,e(c).nodeType),pe(f,1,`text-sm text-text leading-relaxed ${e(d)?"whitespace-pre-wrap":""}`),g(P,y),re(Me,`width: ${e(c).retention*100}%; background: ${T??""}`),g(Se,`${B??""}%`)},[()=>e(d)?e(c).content:Oe(e(c).content),()=>Pe(e(c).retention),()=>(e(c).retention*100).toFixed(0)]),v(k,D)}),n(L);var te=o(L,2),J=r(te),F=o(J,2),ue=r(F,!0);n(F);var ie=o(F,2);n(te),n(X),S((k,c,D,N,Z,t,a,l)=>{re(C,`color: ${k??""}`),g(ee,`${c??""}%`),g(de,D),g(q,`· ${i.memories.length??""} memories`),se(R,"aria-valuenow",N),re(W,`width: ${Z??""}%; background: ${t??""}; box-shadow: 0 0 12px ${a??""}66`),pe(j,1,`flex-shrink-0 rounded-full border px-3 py-1 text-xs font-medium ${i.suggestedAction==="merge"?"border-recall/40 bg-recall/10 text-recall":"border-dream-glow/40 bg-dream/10 text-dream-glow"}`),g(ce,`Suggested: ${i.suggestedAction==="merge"?"Merge":"Review"}`),se(J,"title",`Merge all into highest-retention memory (${l??""}%)`),se(F,"aria-expanded",e(d)),g(ue,e(d)?"Collapse":"Review")},[()=>ge(i.similarity),()=>(i.similarity*100).toFixed(1),()=>Ee(i.similarity),()=>Math.round(i.similarity*100),()=>(i.similarity*100).toFixed(1),()=>ge(i.similarity),()=>ge(i.similarity),()=>(e(u).retention*100).toFixed(0)]),z("click",J,_),z("click",F,()=>w(d,!e(d))),z("click",ie,function(...k){var c;(c=i.onDismiss)==null||c.apply(this,k)}),v(x,X)};G(V,x=>{i.memories.length>0&&e(u)&&x(le)})}v(s,A),ke()}Te(["click"]);var Ve=m(' Detecting…',1),Xe=m(' Error',1),Ye=m(' ',1),qe=m(`
      Couldn't detect duplicates
      `),Je=m('
      '),Qe=m('
      '),$e=m('
      ·
      No duplicates found above threshold.
      Memory is clean.
      '),et=m('
      '),tt=m('
      '),it=m('
      '),at=m(`

      Memory Hygiene — Duplicate Detection

      Cosine-similarity clustering over embeddings. Merges reinforce the winner's FSRS state; losers inherit into the merged node. Dismissed clusters are hidden for this session only.

      `);function ft(s,i){_e(i,!0);let d=K(.8),u=K(xe([])),b=K(xe(new Set)),_=K(!0),A=K(null),V;async function le(t){return await new Promise(l=>setTimeout(l,450)),{clusters:Ie([{similarity:.96,suggestedAction:"merge",memories:[{id:"m-001",content:"BUG FIX: Harmony parser dropped `final` channel tokens when tool call followed. Root cause: 5-layer fallback missed the final channel marker when channel switched mid-stream. Solution: added final-channel detector before tool-call pop. Files: src/parser/harmony.rs",nodeType:"fact",tags:["bug-fix","benchmark-suite","parser"],retention:.91,createdAt:"2026-04-12T14:22:00Z"},{id:"m-002",content:"Fixed Harmony parser final-channel bug — 5-layer fallback was missing the final channel marker when a tool call followed. Added detector before tool pop.",nodeType:"fact",tags:["bug-fix","benchmark-suite"],retention:.64,createdAt:"2026-04-13T09:15:00Z"},{id:"m-003",content:"Harmony parser: final channel dropped on tool-call. Patched the fallback stack.",nodeType:"note",tags:["parser"],retention:.38,createdAt:"2026-04-14T11:02:00Z"}]},{similarity:.88,suggestedAction:"merge",memories:[{id:"m-004",content:"DECISION: Use vLLM prefix caching at 0.35 gpu_memory_utilization for benchmark suite submissions. Alternatives considered: sglang (slower cold start), TensorRT-LLM (deployment friction).",nodeType:"decision",tags:["vllm","benchmark-suite","inference"],retention:.84,createdAt:"2026-04-05T18:44:00Z"},{id:"m-005",content:"Chose vLLM with prefix caching (0.35 mem util) over sglang and TensorRT-LLM for benchmark suite inference.",nodeType:"decision",tags:["vllm","benchmark-suite"],retention:.72,createdAt:"2026-04-06T10:30:00Z"}]},{similarity:.83,suggestedAction:"review",memories:[{id:"m-006",content:"Release process prefers one change per benchmark submission — stacking changes destroyed signal in a prior run.",nodeType:"pattern",tags:["methodology","benchmark-suite"],retention:.88,createdAt:"2026-04-04T22:10:00Z"},{id:"m-007",content:"One-variable-at-a-time rule: never stack multiple changes per submission. Paper 2603.27844 proves +/-2 points is noise.",nodeType:"pattern",tags:["kaggle","methodology"],retention:.67,createdAt:"2026-04-08T16:20:00Z"},{id:"m-008",content:"Lesson: stacking many changes in one benchmark run hid the causal signal. Always isolate variables.",nodeType:"note",tags:["methodology"],retention:.42,createdAt:"2026-04-15T08:55:00Z"}]},{similarity:.78,suggestedAction:"review",memories:[{id:"m-009",content:"Dimensional Illusion performance: 7-minute flow poi set, LED config Parthenos overcook preset, tempo 128 BPM.",nodeType:"event",tags:["dimensional-illusion","poi","performance"],retention:.76,createdAt:"2026-03-28T19:45:00Z"},{id:"m-010",content:"Dimensional Illusion set: 7 min, Parthenos LED overcook, 128 BPM.",nodeType:"event",tags:["dimensional-illusion","poi"],retention:.51,createdAt:"2026-04-02T12:12:00Z"}]},{similarity:.76,suggestedAction:"review",memories:[{id:"m-011",content:"Vestige v2.0.7 shipped active forgetting via Anderson 2025 top-down inhibition + Davis Rac1 cascade. Suppress compounds, reversible 24h.",nodeType:"fact",tags:["vestige","release","active-forgetting"],retention:.93,createdAt:"2026-04-17T03:22:00Z"},{id:"m-012",content:"Active Forgetting feature: compounds on each suppress, 24h reversible labile window, violet implosion animation in graph view.",nodeType:"concept",tags:["vestige","active-forgetting"],retention:.81,createdAt:"2026-04-18T09:07:00Z"}]}],t)}}async function x(){w(_,!0),w(A,null);try{const t=await le(e(d));w(u,t.clusters,!0);const a=new Set(e(u).map(p=>be(p.memories))),l=new Set;for(const p of e(b))a.has(p)&&l.add(p);w(b,l,!0)}catch(t){w(A,t instanceof Error?t.message:"Failed to detect duplicates",!0),w(u,[],!0)}finally{w(_,!1)}}function X(){clearTimeout(V),V=setTimeout(x,250)}function O(t){const a=new Set(e(b));a.add(t),w(b,a,!0)}function Y(t,a,l){console.log("Merge cluster",t,{winnerId:a,loserIds:l}),O(t)}const h=I(()=>e(u).map(t=>({c:t,key:be(t.memories)})).filter(({key:t})=>!e(b).has(t))),C=I(()=>e(h).reduce((t,{c:a})=>t+a.memories.length,0)),ee=50,H=I(()=>e(h).length>ee),de=I(()=>e(H)?e(h).slice(0,ee):e(h));Ce(()=>x()),Re(()=>clearTimeout(V));var U=at(),q=o(r(U),2),R=r(q),W=o(r(R),2);Fe(W);var j=o(W,2),ce=r(j);n(j),n(R);var L=o(R,2),te=r(L);{var J=t=>{var a=Ve();he(2),v(t,a)},F=t=>{var a=Xe();he(2),v(t,a)},ue=t=>{var a=Ye(),l=o(we(a),2),p=r(l);n(l),S(()=>g(p,`${e(h).length??""} ${e(h).length===1?"cluster":"clusters"}, ${e(C)??""} potential duplicate${e(C)===1?"":"s"}`)),v(t,a)};G(te,t=>{e(_)?t(J):e(A)?t(F,1):t(ue,!1)})}n(L);var ie=o(L,2);n(q);var k=o(q,2);{var c=t=>{var a=qe(),l=o(r(a),2),p=r(l,!0);n(l);var E=o(l,2);n(a),S(()=>g(p,e(A))),z("click",E,x),v(t,a)},D=t=>{var a=Qe();oe(a,20,()=>Array(3),Ae,(l,p)=>{var E=Je();v(l,E)}),n(a),v(t,a)},N=t=>{var a=$e();v(t,a)},Z=t=>{var a=it(),l=r(a);{var p=M=>{var f=et(),P=r(f);n(f),S(()=>g(P,`Showing first 50 of ${e(h).length??""} clusters. Raise the diff --git a/apps/dashboard/build/_app/immutable/nodes/7.2YrTacps.js.br b/apps/dashboard/build/_app/immutable/nodes/7.2YrTacps.js.br new file mode 100644 index 0000000000000000000000000000000000000000..30a09c9850310e8eb9a3b1fc10868c5801869d19 GIT binary patch literal 4942 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 M5Dix~W;Gm(j|=Ll-~a#s literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/7.2YrTacps.js.gz b/apps/dashboard/build/_app/immutable/nodes/7.2YrTacps.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..41058caf4d6fd86b8e61a460fb6abf29f28e8605 GIT binary patch literal 5685 zcmV-57Ru=#iwFP!000026SZ6KR@=yu|2+38I-1;!v}p<1*g)(E4u3;3KoTG!f#pD3 zYTJrsNs-zZhj7k(+6UOP&v0Mie!q`0PqJ0rk|o)O%-q?XIkD{iQ(g6|>guXe;}7E~ z5t?N!x&2W%NSC(0vB9dpe_(w{wYD#N?;^rdvdt;O=P|$UCeg4o<<+a^x8aLHQl1jy z&?`>6_#AWE!)Hce!08B|uc?QRgeLe1DaS`d1wKw_U(Tc{K7OSxK5jV;@!6kaVLLt> zoSnUm$}C9Yr(99!sinWoPTUGUb`NTYyXA>Kj(jyYvN1UwzZz6VDvmjoGdAbBdbPXt zDftqVr$|8#G9+#kKEt_*`)|Xz5mm&IVx(MwwKuoc=4u?Ryt@6hJf(v}kLHG^=kC|Z z(bnc1^>}V5``Fn$H^u7Q&}3fNTeEAv`&Qxk2#21}4|P9u-d~+5T)Lys6@CRw zUBbmE2}!!{STE`uTF6;q`W_F3@3KH^Vf)&KmWm__ds<5yb2iZKr!;z!h8u;cAig6h zwlj*p<2bYAHnba-=%(pLL6n#tciF_yT5@EzLUqKLC7~boV2t*2*W-3$wY2u`pI!TC zMz-p@C-Ms!GU4`Ny)zIr`%x_Ut_qp8x}p7CvpX-=YKWB8fS=vw3vPFiVcu=Pf2G-5 za<<>qpQPWvr&hqjp6CM)wvkZ`M?ugIIEs^A*q79Ejz+@{Pb@#(^Fv>7-M3&U3J`_H zM(Ib(tS#B?Zj|UaedN^IqnG&#?a}k+IZhoQJi4S;bA&r(!kt;dSL@!hXS(lnfTb(r zK1aC_?KOx-{Q?@R>j#1-y63EWR_YJ^fF-_|tUJC@OzKq7w1zB(CDwh*_Y5lye3$F+ z1ha<6m&gxw?YmZ*{Z=mNtl1f)8Hk$JR-$@NYKg=j!t8{{0RwVN|Cv5t>QRkoQ%mtO zkX}0ehS&14b#0L4x%T^S|0rp1Qr4cB#60Sf^ocYeFi~xGdEW{7nCvi7w#zB%N9+i6 z+2i8WAA*?1h6d(niRd5#%j7ugM3U8SBHtr6y_siP&)DD=2T zIz2OiT^j^TwI+#g&6)*|iD|<_@LOSC)a>~7l5~MRbI3h^G*s17$UXPLy~&G1E!N;*>Ad z?FDL7sHK7>f_xdJ!tYMZ4i{q%$RLi5`8j{sMCJ@*d68M9L$wi8KJ+_L;FWFTkJ`|K z;}$|ss>;R9A{G2cEMsZK)}SNcjut0TFX3t0VTnfI;9zFJIy`W+?I`s_PKpC1>%L*Z z2!sqB&91btTSu$e_79EjL6tY<rV&Hkmhf(75l=z{Di0E_D_j`SwqVvrTb29eBkOQVwS8E2nl4Gyi=xUeI z(bjTD3rc^$rI(P)_r{dcGWd|l9i^>kBm&Tz8AhNy*<{}Msox2B3lBMTsPl~(5wME& zLdf6$>%TK0UM?v(0N8~fEfmp9I2-<93FTu^vJu!s6^q%!bq-^(_pg^BrRtw3D@SeS~p! z-jj#1x6b-4gr!d$2M5Ri6{FRx83U&h8&^7niB=R!t9|wiXFPj0ZO}6c6k=|}knz^0 za{w_Q{pgIjzG<}YunpWGP?ujnIp47Rt&`}V4Eh-!Zw=aq$7h3X!=rCd&f&Rjv_t&B zIr~neZ_~O#J?z<+XoUK{>ihtm``Gyv`aWRC2ZM${NA?~=Zy$Tlp!XPikFoc&>iq(} zpRw0P!e6la3wFO%-3QS97P{LJ*AHmDMiJBkPdaec2PnKgpstb0x8wYZ@*M%a9fO_& zg(F-*!0&T|GI$7s2Jm2+7)-4d!$^i}Nh-U}B%^ogd;ogw8+}4gjr;a1J*L>jbr*4W zraFA~Y@+WP_euwcKrGG}Kcux)$@o5M3uXz{OKHQPo199b*+N^+88SXZB(^f%whVeA zEvcsuIq3M*0P8|lwqPZ|NhsdCu$(|C-@)8&Hn*$#7>Ca8RIv9Y!M@;nTQKD`n{tZF z0Ryny7BFJa3tW4W@$G_lfm3=@7?+9(z=PiK%+}{e82}dJ8Co~oK!n~SLLq2E@)ja* z=g9a|;39+t4^jH3$jj4AG#v62hn!$nmrKz&3LnbP9SIRI1DL={G1qr!jb8V_J;h`$ zbdu4{)OA6ureZHL6M{9XF0BqO4W>PGtk)lou?Po)i9;-&m$JMe8slRrA zZP0{+9bb2tJLpO7TR=lU=NFPr7^MT%(oY z2JPv=Y!d+3MF8`dukgbGXP)9MV7HJ`p%5PAno=?qp~MN7F-XpJPk%=zlKDeUugAUz zX=X0`G>-TWh^g-X-X>MyPILZy`U%W^dbcGT{(cQcccGjsEUrurj#?nqdYhY|`fbQv z_bzKJ3KFtepXUK~X0+#nWV)>^d_Z^9Hak$ZD9{!U&=%jI8v(HPpy3TRjL~1bQw0IoYg6CIy z{jYz*;L`b`iVt$^G=NhUa7?u#kPV};MvtUg&PrN2SBuOlLda%ljWC;IUNmkI8~(4= z<6G!vvU_FaTAI!mG@Xa@*?hZA1B8X)63Ud0dOe6X!I8*g5Nm5gJn*y)E!$+-7HQb! zGJ;(x5VZ2KrNBsySJ75Jyy(tQcLDX2oP*Yn7?LM3EOyLqd_K-M-J9vAyDlP58BNbe z(o$IyqCdS0loAX@V=q%1zlFpAK*SB~8OY&?Q?>iHqaZ+MQ>>qFkRC=QMRJqbeYvS> z^))qOchR&%Ci<4t?%0qmduUF+YAr|^WI7iKR6r_AE!_5vDWwPs) z^m=^Xzenpzs z57k|Y+_$JLl`9!Dg_(TEt0C1)zH;Ja5^hJMzzctYz+a*YXMPL{1jVEa^6(*p4BQ-g z8Jxvk@QV)#EXp_G^G_~xA${&@?ywxY1Gq4i*r9PlKQNX)PGbt~!zEUjoce3g&(B zkk%V=ASn-KV%9@oh$?&lb$F|a6>4iXLD-zm3MhI7X!Rkg1>qMI+WNIB`a!k+S=DQ% zjQvT^=dh7}|LuRsPOfK?x#TE(xzw*=@qDq%K_pd8(kza|yj}rHkcCgehaK)=Af8%8 z1{U}_*AKf<;&NH2Qx&aWQnGh)d_o}a5xo7kpMLr&h*F+lL9Y+gL{Zq2VT?yG1+YkV z3c~Mf-ITBdi+{4xI$IPXQ5Z}td=UVWNg%6cyLb~Wu2ME7-V6Uh(bk;vRNI8=!Ah^h@+tF}gDQP{R#G&Mk)$N1f@ zX)|Sb<|2c+*R0mv7Okx<%^bR8v)0HWTQs-Ky+mO|Di)L*V^K+#i!7)XKjH(+ar%5d zTRK8&_QQof{K)I?Xn~_Nml}4Zqs37G9F(^FpDDZkKb9IjKV@*pd94WS15|>C)c@Hr znT*1jW3upK*QJVIS3FR7wALWegy$^;l9#f~D8J*I;S(;P;R>sh5Rh-e6N6ZTerz*f z!X;DU0oTR!{Vf|aa0EF2T@t~z=X&6*r|LB_2&@OR(X@f?UG587uVLxC!a2397b|oo zGiqgd5zT|+*2SIgL91!Q&Y*d+u5EpIMfP5QYLR`GfGJN%%o1==#7m+$2LE&2^+Oh1 z6SvPo^dBM`@GvFgKKLOK!8tBp7<3{1iN@Ts$Z-@2Xd9)xMVhd?CRoIVA(+jQ%%`Ed zlVqn_=b031k~xJydPrM?o{N>YvH#g~@WWvLpdk%xYE-RRMt+ zd8o}HJH{JOfG(a-kHgCrs%=xExd=ZA-M@iO1(cP>LQs}Z?H8?Da~7245-3$TS~G&> zRvLwct}XJ8DZ`OKNz6R9vP7 zBDDaY9cdO(2yx0LzV`@aNCwd=G(i-YU}YtR2m$EpDOv+WVHj7*O07Z3DQx#BIX*R! zA>HF~5KV@_FzF_~l+UPu3K^R(UsUD5-UPvL;pTy0304o?8B*&v-r%UVrH-exUDvZk{XAu8a1YLyXl;M9%;EIr|^@T#NoYw5tvi*Q% zEzet4qH0ZxOlzft%rOrz%m+jw7eYpf491jrisDx4K^LzIoSThwH*)VFhH7vMjsmaP zO<<3ueh)XKkB%iye1HuO*a|=~6KHl*e1=@~BQFY~-sDFxtu5SucH2r3RHSTA2DVVlqd=?XUZ{5ANHINiqlwVd`LK*I&SubPlDK-Nz1+6w9p5-35*!R`)v z!>->0Wha117^TuXxKT8~y&^|Js2)e8R$n7q?+z#c9vea)*rpGhldCI# zM$xr$$odf``QWl{>K0^wB<=e$27s^xYYl*Jj|;54k{h3qO-NZ1*c$}cg4`sEO)naU zn11^mm6JRtI}Gv#a?IQs?1t23n1P>+V$?jIlc0A5Ken(P^x@{-@uvlAYJbh)KvuoV9Dk2A{c%k{MzD>c@3jO zdo{P8ODc@}`=S?_Q?F5M}?I}6z`c`;i}jY-rc^6Ce(`YhFBM=!Gawc z;5zp%hNYPIA){FN0dEb6!CYCv-w?1+nz9~1xyL{o;Gd)Uino@@I-(bslB|q~gNcHn z1`tib`2^r#Q8LLh$&Yv;rIcCT(t6V_U%y7~=HURr+DytLaODnVYT=s*wG#CZFQzfz2UJC|e73{T_wt{Euk9(pKEBNIMlRQZT_DMDw0O>DUmsD-wK;d1Hr+2z z&R#BYE-&EZ9sBt9yKhWyTtjyY8;tfgmqWlp4SKA;&nP3mxx<8x_jV#3Z|>lG>|-a< zzv5*bY&yoK_8!;IirYG83vTNi7q@keKFBVdym3T!;evepW2AVVO z>0YV((|q@cm-;{BeU$)K8FQUUc4Js5Kt6)vqD+i0%uBe*7phqQ{OPAkyW=>u4K25l zR{kvocUO$wR@W%t$d*2X1;u_)-HHlKPw~C)l=1c}U2rPo)t4({L+Ec%Ih*)xkJgNq zz!$ibjxtc(vbQh77F zOK%IvcS@_gM~y@rFGkt&&8oWTzpO4V1vJhtFYP*S)Geui?y5Tzte|*QqWDw|Qyu4} z4qxcmy{t^y*g4EPyAH=rdAUj5Y?=!5j$WViqp>`E`~E_+R32B3EH%U;%Ld(Nku=K~r8Qc$-x^7|@ySH|a7 zUeI-rYIZL|p2v$X706n@M$hOcgC61SnEav<@`$$z#O#d%xp7kZq5O_Nqf)%<=eP3j b>ALc7BV}w9f;YKu|LuPPo@6gmz&QW_$LIk@ literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/7.jHtvjgRi.js.br b/apps/dashboard/build/_app/immutable/nodes/7.jHtvjgRi.js.br deleted file mode 100644 index 3b795a7d5d7e4593e631f799dea451dcd815f6af..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4943 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 N3;f}##;k@@@d=!u$D{xN diff --git a/apps/dashboard/build/_app/immutable/nodes/7.jHtvjgRi.js.gz b/apps/dashboard/build/_app/immutable/nodes/7.jHtvjgRi.js.gz deleted file mode 100644 index 89431863176e11e1f5f658be6625c17f10535e4d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5686 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 '),Ue=m('
      Source

      '),Ve=m('
      Target

      '),Ge=m(`
      Target Memory
      '),Ue=m('
      Source

      '),Ve=m('
      Target

      '),Ge=m(`
      Target Memory
      `,1),He=m('
      ◎

      '),Je=m(' '),Le=m(" "),We=m(" "),Xe=m(" "),Ye=m(' '),Ze=m('

      '),et=m('

      '),tt=m('
      ◬

      No connections found for this query.

      '),rt=m('
      '),at=m('
      '),st=m('
      '),it=m(`

      Explore Connections

      Source Memory

      Importance Scorer

      4-channel neuroscience scoring: novelty, arousal, reward, attention

      `);function ft(he,we){ze(we,!0);let V=I(""),G=I(""),F=I(null),C=I(null),B=I(Ae([])),$=I("associations"),O=I(!1),H=I(""),D=I(null);const le={associations:{icon:"◎",desc:"Spreading activation — find related memories via graph traversal"},chains:{icon:"⟿",desc:"Build reasoning path from source to target memory"},bridges:{icon:"⬡",desc:"Find connecting memories between two concepts"}};async function ve(){if(e(V).trim()){b(O,!0);try{const s=await X.search(e(V),1);s.results.length>0&&(b(F,s.results[0],!0),await Y())}catch{}finally{b(O,!1)}}}async function pe(){if(e(G).trim()){b(O,!0);try{const s=await X.search(e(G),1);s.results.length>0&&(b(C,s.results[0],!0),e(F)&&await Y())}catch{}finally{b(O,!1)}}}async function Y(){if(e(F)){b(O,!0);try{const s=(e($)==="chains"||e($)==="bridges")&&e(C)?e(C).id:void 0,i=await X.explore(e(F).id,e($),s);b(B,i.results||i.nodes||i.chain||i.bridges||[],!0)}catch{b(B,[],!0)}finally{b(O,!1)}}}async function ke(){e(H).trim()&&b(D,await X.importance(e(H)),!0)}function Se(s){b($,s,!0),e(F)&&Y()}var Z=it(),ee=a(r(Z),2);ie(ee,20,()=>["associations","chains","bridges"],ne,(s,i)=>{var d=Re(),_=r(d),h=r(_,!0);t(_);var f=a(_,2),p=r(f,!0);t(f);var n=a(f,2),g=r(n,!0);t(n),t(d),y(w=>{oe(d,1,`flex flex-col items-center gap-1 p-3 rounded-xl text-sm transition diff --git a/apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.br b/apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.br new file mode 100644 index 0000000000000000000000000000000000000000..87e1326543b67dbb29444ac8c2387906b9d2e1ba GIT binary patch literal 3017 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 N?tkeSwP?~M005}3wtoNs literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/9.BWaJ-VBd.js.br b/apps/dashboard/build/_app/immutable/nodes/9.BWaJ-VBd.js.br deleted file mode 100644 index 36cc5aa1c184bdc048a201d0abcccd4e45596402..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2951 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 diff --git a/apps/dashboard/build/_app/immutable/nodes/9.BWaJ-VBd.js.gz b/apps/dashboard/build/_app/immutable/nodes/9.BWaJ-VBd.js.gz deleted file mode 100644 index 4766f92cd66f7b2f8fde53313bba014dd6a50331..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3347 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 '),_e=m('
      '),ge=m('
      ',1),he=m('
      '),ye=m('
      '),$e=m('
      Cognitive Search Pipeline
      ');function be(q,F){ee(F,!0);let S=Q(F,"resultCount",3,0),j=Q(F,"durationMs",3,0),I=Q(F,"active",3,!1);const p=[{name:"Overfetch",icon:"◎",color:"#818CF8",desc:"Pull 3x results from hybrid search"},{name:"Rerank",icon:"⟿",color:"#00A8FF",desc:"Re-score by relevance quality"},{name:"Temporal",icon:"◷",color:"#00D4FF",desc:"Recent memories get recency bonus"},{name:"Access",icon:"◇",color:"#00FFD1",desc:"FSRS-6 retention threshold filter"},{name:"Context",icon:"◬",color:"#FFB800",desc:"Encoding specificity matching"},{name:"Compete",icon:"⬡",color:"#FF3CAC",desc:"Retrieval-induced forgetting"},{name:"Activate",icon:"◈",color:"#9D00FF",desc:"Spreading activation cascade"}];let _=K(-1),g=K(!1),u=K(!1);ie(()=>{I()&&!e(g)&&M()});function M(){A(g,!0),A(_,-1),A(u,!1);const t=Math.max(1500,(j()||50)*2),a=t/(p.length+1);p.forEach((i,v)=>{setTimeout(()=>{A(_,v,!0)},a*(v+1))}),setTimeout(()=>{A(u,!0),A(g,!1)},t)}var D=$e(),b=o(D),L=d(o(b),2);{var V=t=>{var a=xe(),i=o(a);s(a),$(()=>x(i,`${S()??""} results in ${j()??""}ms`)),l(t,a)};w(L,t=>{e(u)&&t(V)})}s(b);var P=d(b,2);re(P,21,()=>p,ae,(t,a,i)=>{const v=X(()=>i<=e(_)),E=X(()=>i===e(_)&&e(g));var k=ge(),h=ne(k),y=o(h),J=o(y,!0);s(y);var R=d(y,2),T=o(R,!0);s(R),s(h);var U=d(h,2);{var W=B=>{var c=_e();$(()=>C(c,`background: ${i{i{fe(y,1,`w-8 h-8 rounded-full flex items-center justify-center text-xs transition-all duration-300 +import"../chunks/Bzak7iHL.js";import{i as oe}from"../chunks/BUoSzNdg.js";import{p as ee,aB as ie,g as e,h as A,d as o,e as d,r as s,f as ne,t as $,a as te,s as K,u as X,A as Z}from"../chunks/CpWkWWOo.js";import{s as x,d as de,a as ce}from"../chunks/BlVfL1ME.js";import{a as l,f as m}from"../chunks/CHOnp4oo.js";import{i as w}from"../chunks/B4yTwGkE.js";import{e as re,i as ae}from"../chunks/CGEBXrjl.js";import{s as C}from"../chunks/Cx-f-Pzo.js";import{s as le,a as me}from"../chunks/C6HuKgyx.js";import{w as ve,e as ue}from"../chunks/MAY1QfFZ.js";import{E as O}from"../chunks/CcUbQ_Wl.js";import{s as pe}from"../chunks/A7po6GxK.js";import{s as fe}from"../chunks/aVbAZ-t7.js";import{p as Q}from"../chunks/V6gjw5Ec.js";var xe=m(' '),_e=m('
      '),ge=m('
      ',1),he=m('
      '),ye=m('
      '),$e=m('
      Cognitive Search Pipeline
      ');function be(q,F){ee(F,!0);let S=Q(F,"resultCount",3,0),j=Q(F,"durationMs",3,0),I=Q(F,"active",3,!1);const p=[{name:"Overfetch",icon:"◎",color:"#818CF8",desc:"Pull 3x results from hybrid search"},{name:"Rerank",icon:"⟿",color:"#00A8FF",desc:"Re-score by relevance quality"},{name:"Temporal",icon:"◷",color:"#00D4FF",desc:"Recent memories get recency bonus"},{name:"Access",icon:"◇",color:"#00FFD1",desc:"FSRS-6 retention threshold filter"},{name:"Context",icon:"◬",color:"#FFB800",desc:"Encoding specificity matching"},{name:"Compete",icon:"⬡",color:"#FF3CAC",desc:"Retrieval-induced forgetting"},{name:"Activate",icon:"◈",color:"#9D00FF",desc:"Spreading activation cascade"}];let _=K(-1),g=K(!1),u=K(!1);ie(()=>{I()&&!e(g)&&M()});function M(){A(g,!0),A(_,-1),A(u,!1);const t=Math.max(1500,(j()||50)*2),a=t/(p.length+1);p.forEach((i,v)=>{setTimeout(()=>{A(_,v,!0)},a*(v+1))}),setTimeout(()=>{A(u,!0),A(g,!1)},t)}var D=$e(),b=o(D),L=d(o(b),2);{var V=t=>{var a=xe(),i=o(a);s(a),$(()=>x(i,`${S()??""} results in ${j()??""}ms`)),l(t,a)};w(L,t=>{e(u)&&t(V)})}s(b);var P=d(b,2);re(P,21,()=>p,ae,(t,a,i)=>{const v=X(()=>i<=e(_)),E=X(()=>i===e(_)&&e(g));var k=ge(),h=ne(k),y=o(h),J=o(y,!0);s(y);var R=d(y,2),T=o(R,!0);s(R),s(h);var U=d(h,2);{var W=B=>{var c=_e();$(()=>C(c,`background: ${i{i{fe(y,1,`w-8 h-8 rounded-full flex items-center justify-center text-xs transition-all duration-300 ${e(E)?"scale-125":""}`),C(y,`background: ${e(v)?e(a).color+"25":"rgba(255,255,255,0.03)"}; border: 1.5px solid ${(e(v)?e(a).color:"rgba(255,255,255,0.06)")??""}; color: ${(e(v)?e(a).color:"#4a4a7a")??""}; diff --git a/apps/dashboard/build/_app/immutable/nodes/9.Vu2AXN40.js.br b/apps/dashboard/build/_app/immutable/nodes/9.Vu2AXN40.js.br new file mode 100644 index 0000000000000000000000000000000000000000..90505a6864d339ceb8d92833638d7089a47365cd GIT binary patch literal 2949 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 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/9.Vu2AXN40.js.gz b/apps/dashboard/build/_app/immutable/nodes/9.Vu2AXN40.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..433c6c18e59a8db82d79921db6f9afbb052dc84c GIT binary patch literal 3345 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 b{}6U*|LnXG03QGV_y>oT literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/version.json b/apps/dashboard/build/_app/version.json index 6d40749..a0b8a69 100644 --- a/apps/dashboard/build/_app/version.json +++ b/apps/dashboard/build/_app/version.json @@ -1 +1 @@ -{"version":"2.1.21"} \ No newline at end of file +{"version":"2.1.22"} \ No newline at end of file diff --git a/apps/dashboard/build/_app/version.json.br b/apps/dashboard/build/_app/version.json.br index 3fe972d..7ee1248 100644 --- a/apps/dashboard/build/_app/version.json.br +++ b/apps/dashboard/build/_app/version.json.br @@ -1 +1 @@ - {"version":"2.1.21"} \ No newline at end of file + {"version":"2.1.22"} \ No newline at end of file diff --git a/apps/dashboard/build/_app/version.json.gz b/apps/dashboard/build/_app/version.json.gz index e7b357ea7b04f3cd6f4f1228c77a15f920f48eb6..9667dd0a5c88d811afedca6ce9dd19bac860a992 100644 GIT binary patch delta 17 YcmdPUm>|Oww2GDC_{nRfA`A=+04{k1`2YX_ delta 17 YcmdPUm>|OwvWk^qUipM_5e5bZ04Z?
      + +{#if visible} +
      + + + {#if expanded && receipt} +
      +
      +
      +
      Claim
      +

      {displayClaim?.text ?? receipt.draftPreview}

      +
      +
      +
      Verdict
      +

      {displayClaim?.decision ?? receipt.overall} · {displayClaim?.evidence_state ?? verdict}

      +
      +
      +
      Precedent
      +
        + {#each precedentText(displayClaim) as item} +
      • {item}
        • + {/each} +
      +
      +
      +
      Fix
      +

      {displayClaim?.fix || 'No change required.'}

      +
      +
      + +
      + Appeal + {#if appealClaim && receipt.verdictBar === 'VETO'} + + + + {:else if receipt.verdictBar === 'APPEALED'} +

      Appeal recorded.

      + {:else} +

      No appealable veto in this receipt.

      + {/if} +
      +
      + {/if} +
      +{/if} + + diff --git a/apps/dashboard/src/lib/stores/api.ts b/apps/dashboard/src/lib/stores/api.ts index f4b77e0..536eaea 100644 --- a/apps/dashboard/src/lib/stores/api.ts +++ b/apps/dashboard/src/lib/stores/api.ts @@ -12,7 +12,10 @@ import type { ConsolidationResult, IntentionItem, SuppressResult, - UnsuppressResult + UnsuppressResult, + SanhedrinAppealReason, + SanhedrinAppealResponse, + SanhedrinLatestResponse } from '$types'; const BASE = '/api'; @@ -119,5 +122,14 @@ export const api = { fetcher>('/deep_reference', { method: 'POST', body: JSON.stringify({ query, depth }) - }) + }), + + sanhedrin: { + latest: () => fetcher('/sanhedrin/latest'), + appeal: (reason: SanhedrinAppealReason, note?: string, claimId?: string, receiptId?: string) => + fetcher('/sanhedrin/appeal', { + method: 'POST', + body: JSON.stringify({ reason, note, claimId, receiptId }) + }) + } }; diff --git a/apps/dashboard/src/lib/stores/toast.ts b/apps/dashboard/src/lib/stores/toast.ts index 6daef38..6bc195c 100644 --- a/apps/dashboard/src/lib/stores/toast.ts +++ b/apps/dashboard/src/lib/stores/toast.ts @@ -61,6 +61,13 @@ function createToastStore() { update(list => { const next = [entry, ...list]; if (next.length > MAX_VISIBLE) { + for (const dropped of next.slice(MAX_VISIBLE)) { + const handle = dwellTimers.get(dropped.id); + if (handle) clearTimeout(handle); + dwellTimers.delete(dropped.id); + dwellPaused.delete(dropped.id); + dwellStart.delete(dropped.id); + } return next.slice(0, MAX_VISIBLE); } return next; @@ -229,6 +236,18 @@ function createToastStore() { }; } + case 'HookVerdictRecorded': { + const verdict = String(d.verdict ?? 'NOTE'); + const reason = String(d.reason ?? 'Sanhedrin receipt updated'); + return { + type: event.type, + title: `Sanhedrin ${verdict}`, + body: reason, + color, + dwellMs: verdict === 'VETO' ? 8000 : DEFAULT_DWELL_MS, + }; + } + // Noise — never toast case 'Heartbeat': case 'SearchPerformed': diff --git a/apps/dashboard/src/lib/types/index.ts b/apps/dashboard/src/lib/types/index.ts index a76b092..b2b3bac 100644 --- a/apps/dashboard/src/lib/types/index.ts +++ b/apps/dashboard/src/lib/types/index.ts @@ -167,6 +167,7 @@ export type VestigeEventType = | 'ActivationSpread' | 'ImportanceScored' | 'DeepReferenceCompleted' + | 'HookVerdictRecorded' | 'Heartbeat'; export interface VestigeEvent { @@ -202,6 +203,64 @@ export interface UnsuppressResult { stability: number; } +export type VerdictLevel = 'PASS' | 'NOTE' | 'CAUTION' | 'VETO' | 'APPEALED'; +export type SanhedrinAppealReason = 'stale' | 'wrong' | 'too_strict'; + +export interface SanhedrinAppealState { + status: 'open' | 'appealed'; + actions?: SanhedrinAppealReason[]; + lastReason?: SanhedrinAppealReason; + note?: string; +} + +export interface SanhedrinPrecedent { + type?: string; + summary?: string; + command?: string; + exitCode?: number | null; + evidence?: string; +} + +export interface SanhedrinClaim { + id: string; + text: string; + fingerprint: string; + class: string; + subject: string; + risk: string; + evidence_state: string; + decision: string; + precedent: SanhedrinPrecedent[]; + fix: string; + appeal: SanhedrinAppealState; +} + +export interface SanhedrinReceipt { + schema: string; + id: string; + draftId: string; + createdAt: string; + overall: string; + verdictBar: VerdictLevel; + summary: string; + draftPreview: string; + claims: SanhedrinClaim[]; + receipts: Array>; + source?: Record; +} + +export interface SanhedrinLatestResponse { + receipt: SanhedrinReceipt | null; + stateDir: string; + receiptPath?: string; + htmlPath?: string; +} + +export interface SanhedrinAppealResponse { + appeal: Record; + receipt: SanhedrinReceipt; +} + // Intentions (prospective memory) export interface IntentionItem { id: string; @@ -238,6 +297,7 @@ export const EVENT_TYPE_COLORS: Record = { Rac1CascadeSwept: '#6E3FFF', SearchPerformed: '#818CF8', DeepReferenceCompleted: '#C4B5FD', + HookVerdictRecorded: '#F59E0B', DreamStarted: '#9D00FF', DreamProgress: '#B44AFF', DreamCompleted: '#C084FC', diff --git a/apps/dashboard/src/routes/+layout.svelte b/apps/dashboard/src/routes/+layout.svelte index c00c098..ca19491 100644 --- a/apps/dashboard/src/routes/+layout.svelte +++ b/apps/dashboard/src/routes/+layout.svelte @@ -16,6 +16,7 @@ import ForgettingIndicator from '$lib/components/ForgettingIndicator.svelte'; import InsightToast from '$lib/components/InsightToast.svelte'; import AmbientAwarenessStrip from '$lib/components/AmbientAwarenessStrip.svelte'; + import VerdictBar from '$lib/components/VerdictBar.svelte'; import ThemeToggle from '$lib/components/ThemeToggle.svelte'; import { initTheme } from '$stores/theme'; @@ -199,6 +200,7 @@
      +
      {@render children()}
      diff --git a/crates/vestige-core/Cargo.toml b/crates/vestige-core/Cargo.toml index 1e159ea..e84625e 100644 --- a/crates/vestige-core/Cargo.toml +++ b/crates/vestige-core/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "vestige-core" -version = "2.1.21" +version = "2.1.22" edition = "2024" rust-version = "1.91" authors = ["Vestige Team"] diff --git a/crates/vestige-mcp/Cargo.toml b/crates/vestige-mcp/Cargo.toml index 8dafa5e..b0a5490 100644 --- a/crates/vestige-mcp/Cargo.toml +++ b/crates/vestige-mcp/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "vestige-mcp" -version = "2.1.21" +version = "2.1.22" edition = "2024" description = "Cognitive memory MCP server for AI agents - FSRS-6, spreading activation, synaptic tagging, 3D dashboard, and 130 years of memory research" authors = ["samvallad33"] @@ -47,7 +47,7 @@ path = "src/bin/cli.rs" # Only `bundled-sqlite` is always on. `embeddings` and `vector-search` are # toggled via vestige-mcp's own feature flags below so `--no-default-features` # actually works (previously hardcoded here, which silently defeated the flag). -vestige-core = { version = "2.1.21", path = "../vestige-core", default-features = false, features = ["bundled-sqlite"] } +vestige-core = { version = "2.1.22", path = "../vestige-core", default-features = false, features = ["bundled-sqlite"] } # ============================================================================ # MCP Server Dependencies diff --git a/crates/vestige-mcp/src/autopilot.rs b/crates/vestige-mcp/src/autopilot.rs index 4b4c260..2db04a8 100644 --- a/crates/vestige-mcp/src/autopilot.rs +++ b/crates/vestige-mcp/src/autopilot.rs @@ -435,6 +435,7 @@ async fn handle_event( | VestigeEvent::MemoryUnsuppressed { .. } | VestigeEvent::Rac1CascadeSwept { .. } | VestigeEvent::DeepReferenceCompleted { .. } + | VestigeEvent::HookVerdictRecorded { .. } | VestigeEvent::DreamStarted { .. } | VestigeEvent::DreamProgress { .. } | VestigeEvent::DreamCompleted { .. } diff --git a/crates/vestige-mcp/src/dashboard/events.rs b/crates/vestige-mcp/src/dashboard/events.rs index a6807e2..8edb238 100644 --- a/crates/vestige-mcp/src/dashboard/events.rs +++ b/crates/vestige-mcp/src/dashboard/events.rs @@ -85,6 +85,16 @@ pub enum VestigeEvent { timestamp: DateTime, }, + // -- Hook verdicts -- + HookVerdictRecorded { + hook: String, + verdict: String, + phase: String, + reason: String, + receipt_id: Option, + timestamp: DateTime, + }, + // -- Dream -- DreamStarted { memory_count: usize, diff --git a/crates/vestige-mcp/src/dashboard/handlers.rs b/crates/vestige-mcp/src/dashboard/handlers.rs index 78e3b87..df3fc35 100644 --- a/crates/vestige-mcp/src/dashboard/handlers.rs +++ b/crates/vestige-mcp/src/dashboard/handlers.rs @@ -3,6 +3,9 @@ //! v2.0: Adds cognitive operation endpoints (dream, explore, predict, importance, consolidation) use std::cmp::Reverse; +use std::fs::{self, OpenOptions}; +use std::io::Write; +use std::path::{Path as FsPath, PathBuf}; use axum::extract::{Path, Query, State}; use axum::http::StatusCode; @@ -342,6 +345,328 @@ pub async fn unsuppress_memory( }))) } +#[derive(Debug, Deserialize)] +pub struct SanhedrinAppealRequest { + pub reason: String, + pub note: Option, + #[serde(rename = "receiptId")] + pub receipt_id: Option, + #[serde(rename = "claimId")] + pub claim_id: Option, +} + +/// Return the latest Sanhedrin receipt written by the Stop-hook bridge. +pub async fn get_sanhedrin_latest() -> Result, StatusCode> { + let state_dir = sanhedrin_state_dir(); + let latest_path = state_dir.join("latest.json"); + if !latest_path.exists() { + return Ok(Json(serde_json::json!({ + "receipt": null, + "stateDir": state_dir, + }))); + } + + let raw = fs::read_to_string(&latest_path).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; + let receipt: Value = + serde_json::from_str(&raw).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; + + Ok(Json(serde_json::json!({ + "receipt": receipt, + "stateDir": state_dir, + "receiptPath": latest_path, + "htmlPath": state_dir.join("latest.html"), + }))) +} + +/// Record feedback that a Sanhedrin veto was stale, wrong, or too strict. +/// +/// This intentionally does not promote, demote, suppress, edit, or delete any +/// memory. The hook reads this ledger and suppresses future same-fingerprint +/// vetoes, which keeps appeal training scoped to Sanhedrin behavior. +pub async fn appeal_sanhedrin( + State(state): State, + Json(req): Json, +) -> Result, StatusCode> { + let reason = req.reason.trim().to_ascii_lowercase(); + if !matches!(reason.as_str(), "stale" | "wrong" | "too_strict") { + return Err(StatusCode::BAD_REQUEST); + } + + let state_dir = sanhedrin_state_dir(); + let latest_path = state_dir.join("latest.json"); + let raw = match fs::read_to_string(&latest_path) { + Ok(raw) => raw, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => { + return Err(StatusCode::NOT_FOUND); + } + Err(_) => return Err(StatusCode::INTERNAL_SERVER_ERROR), + }; + let mut receipt: Value = serde_json::from_str(&raw).map_err(|_| StatusCode::BAD_REQUEST)?; + let original_receipt = receipt.clone(); + let note = req.note.unwrap_or_default(); + let receipt_id = receipt + .get("id") + .and_then(Value::as_str) + .map(ToOwned::to_owned); + let receipt_id_ref = receipt_id.as_deref().ok_or(StatusCode::BAD_REQUEST)?; + let _ = sanitize_receipt_id(receipt_id_ref)?; + let expected_receipt_id = req.receipt_id.as_deref().ok_or(StatusCode::BAD_REQUEST)?; + if expected_receipt_id != receipt_id_ref { + return Err(StatusCode::CONFLICT); + } + if receipt + .get("verdictBar") + .and_then(Value::as_str) + .map(|v| v != "VETO") + .unwrap_or(true) + { + return Err(StatusCode::CONFLICT); + } + let claim = mark_sanhedrin_claim(&mut receipt, &reason, ¬e, req.claim_id.as_deref())?; + + let appeal = serde_json::json!({ + "timestamp": Utc::now().to_rfc3339(), + "receiptId": receipt_id.as_deref(), + "claimId": claim.get("id").and_then(Value::as_str), + "claimFingerprint": claim.get("fingerprint").and_then(Value::as_str), + "claim": claim.get("text").and_then(Value::as_str), + "reason": &reason, + "note": ¬e, + "status": "active", + }); + + set_json_field(&mut receipt, "overall", "appealed"); + set_json_field(&mut receipt, "verdictBar", "APPEALED"); + set_json_field(&mut receipt, "summary", &format!("Appealed as {}.", reason)); + save_sanhedrin_receipt(&state_dir, &receipt)?; + if let Err(err) = append_sanhedrin_appeal(&state_dir, &appeal) { + let _ = save_sanhedrin_receipt(&state_dir, &original_receipt); + return Err(err); + } + + state.emit(VestigeEvent::HookVerdictRecorded { + hook: "sanhedrin".to_string(), + verdict: "APPEALED".to_string(), + phase: "appeal".to_string(), + reason: reason.clone(), + receipt_id: receipt_id.clone(), + timestamp: Utc::now(), + }); + + Ok(Json(serde_json::json!({ + "appeal": appeal, + "receipt": receipt, + }))) +} + +fn sanhedrin_state_dir() -> PathBuf { + std::env::var_os("VESTIGE_SANHEDRIN_STATE_DIR") + .map(PathBuf::from) + .or_else(|| { + std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".vestige/sanhedrin")) + }) + .unwrap_or_else(|| PathBuf::from(".vestige/sanhedrin")) +} + +fn ensure_sanhedrin_dirs(state_dir: &FsPath) -> Result<(), StatusCode> { + fs::create_dir_all(state_dir.join("receipts")).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) +} + +fn mark_sanhedrin_claim( + receipt: &mut Value, + reason: &str, + note: &str, + claim_id: Option<&str>, +) -> Result { + let claim_id = claim_id.ok_or(StatusCode::BAD_REQUEST)?; + let claims = receipt + .get_mut("claims") + .and_then(Value::as_array_mut) + .ok_or(StatusCode::BAD_REQUEST)?; + + if claims.is_empty() { + return Err(StatusCode::BAD_REQUEST); + } + + let selected = claims + .iter() + .position(|claim| claim.get("id").and_then(Value::as_str) == Some(claim_id)) + .ok_or(StatusCode::NOT_FOUND)?; + + if claims + .get(selected) + .and_then(|claim| claim.get("decision")) + .and_then(Value::as_str) + != Some("veto") + { + return Err(StatusCode::CONFLICT); + } + + let claim = claims + .get_mut(selected) + .and_then(Value::as_object_mut) + .ok_or(StatusCode::BAD_REQUEST)?; + + claim.insert( + "decision".to_string(), + Value::String("appealed".to_string()), + ); + claim.insert( + "evidence_state".to_string(), + Value::String("appealed".to_string()), + ); + claim.insert( + "appeal".to_string(), + serde_json::json!({ + "status": "appealed", + "lastReason": reason, + "note": note, + "actions": ["stale", "wrong", "too_strict"], + }), + ); + + Ok(Value::Object(claim.clone())) +} + +fn set_json_field(receipt: &mut Value, key: &str, value: &str) { + if let Some(obj) = receipt.as_object_mut() { + obj.insert(key.to_string(), Value::String(value.to_string())); + } +} + +fn save_sanhedrin_receipt(state_dir: &FsPath, receipt: &Value) -> Result<(), StatusCode> { + ensure_sanhedrin_dirs(state_dir)?; + let rendered = render_sanhedrin_receipt_html(receipt); + let pretty = serde_json::to_string_pretty(receipt).map_err(|_| StatusCode::BAD_REQUEST)?; + let safe_id = receipt + .get("id") + .and_then(Value::as_str) + .map(sanitize_receipt_id) + .transpose()?; + + if let Some(safe_id) = safe_id { + write_atomic( + &state_dir.join("receipts").join(format!("{}.json", safe_id)), + pretty.as_bytes(), + )?; + write_atomic( + &state_dir.join("receipts").join(format!("{}.html", safe_id)), + rendered.as_bytes(), + )?; + } + + write_atomic(&state_dir.join("latest.json"), pretty.as_bytes())?; + write_atomic(&state_dir.join("latest.html"), rendered.as_bytes())?; + Ok(()) +} + +fn append_sanhedrin_appeal(state_dir: &FsPath, appeal: &Value) -> Result<(), StatusCode> { + ensure_sanhedrin_dirs(state_dir)?; + let mut appeals = OpenOptions::new() + .create(true) + .append(true) + .open(state_dir.join("appeals.jsonl")) + .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; + writeln!(appeals, "{}", appeal).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) +} + +fn sanitize_receipt_id(id: &str) -> Result<&str, StatusCode> { + if !id.is_empty() + && id + .bytes() + .all(|b| b.is_ascii_alphanumeric() || matches!(b, b'_' | b'-')) + { + Ok(id) + } else { + Err(StatusCode::BAD_REQUEST) + } +} + +fn write_atomic(path: &FsPath, bytes: &[u8]) -> Result<(), StatusCode> { + let parent = path.parent().ok_or(StatusCode::INTERNAL_SERVER_ERROR)?; + fs::create_dir_all(parent).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; + let tmp = path.with_extension(format!( + "{}.tmp", + Utc::now().timestamp_nanos_opt().unwrap_or_default() + )); + fs::write(&tmp, bytes).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; + fs::rename(&tmp, path).map_err(|_| { + let _ = fs::remove_file(&tmp); + StatusCode::INTERNAL_SERVER_ERROR + }) +} + +fn render_sanhedrin_receipt_html(receipt: &Value) -> String { + let verdict = escape_html( + receipt + .get("verdictBar") + .and_then(Value::as_str) + .unwrap_or("PASS"), + ); + let summary = escape_html(receipt.get("summary").and_then(Value::as_str).unwrap_or("")); + let mut claims_html = String::new(); + + if let Some(claims) = receipt.get("claims").and_then(Value::as_array) { + for claim in claims { + let text = escape_html(claim.get("text").and_then(Value::as_str).unwrap_or("")); + let decision = escape_html(claim.get("decision").and_then(Value::as_str).unwrap_or("")); + let evidence_state = escape_html( + claim + .get("evidence_state") + .and_then(Value::as_str) + .unwrap_or(""), + ); + let fix = escape_html( + claim + .get("fix") + .and_then(Value::as_str) + .filter(|s| !s.is_empty()) + .unwrap_or("No change required."), + ); + let mut precedents = String::new(); + if let Some(items) = claim.get("precedent").and_then(Value::as_array) { + for item in items { + let summary = item + .get("summary") + .and_then(Value::as_str) + .unwrap_or("Precedent recorded."); + precedents.push_str(&format!("
    • {}
      • ", escape_html(summary))); + } + } + claims_html.push_str(&format!( + "
      {} / {}

      {}

      Fix: {}

      Appeal: stale | wrong | too_strict

        {}
      ", + decision, evidence_state, text, fix, precedents + )); + } + } + + format!( + r#" +Vestige Veto Receipt + +
      Verdict{}
      +

      Veto Receipt

      {}

      {} +"#, + verdict, summary, claims_html + ) +} + +fn escape_html(value: &str) -> String { + value + .replace('&', "&") + .replace('<', "<") + .replace('>', ">") + .replace('"', """) + .replace('\'', "'") +} + /// Get system stats pub async fn get_stats(State(state): State) -> Result, StatusCode> { let stats = state diff --git a/crates/vestige-mcp/src/dashboard/mod.rs b/crates/vestige-mcp/src/dashboard/mod.rs index 6bf9bc1..2a3b5c9 100644 --- a/crates/vestige-mcp/src/dashboard/mod.rs +++ b/crates/vestige-mcp/src/dashboard/mod.rs @@ -176,6 +176,9 @@ fn build_router_inner(state: AppState, port: u16) -> (Router, AppState) { // Wraps crate::tools::cross_reference::execute. Emits // DeepReferenceCompleted so Graph3D can glide, pulse, and arc. .route("/api/deep_reference", post(handlers::deep_reference_query)) + // Sanhedrin receipts (v2.1.22): latest local hook verdict + appeal training. + .route("/api/sanhedrin/latest", get(handlers::get_sanhedrin_latest)) + .route("/api/sanhedrin/appeal", post(handlers::appeal_sanhedrin)) .layer( ServiceBuilder::new() .concurrency_limit(50) diff --git a/hooks/sanhedrin-local.py b/hooks/sanhedrin-local.py index aec10ff..45064af 100755 --- a/hooks/sanhedrin-local.py +++ b/hooks/sanhedrin-local.py @@ -25,8 +25,15 @@ import unicodedata import urllib.error import urllib.request from dataclasses import asdict, dataclass, field, replace +from pathlib import Path from typing import Any +sys.path.insert(0, str(Path(__file__).resolve().parent)) +try: + import sanhedrin_core +except Exception: + sanhedrin_core = None + def env_int(name: str, default: int) -> int: try: @@ -1059,6 +1066,139 @@ def render_legacy_from_verdicts(verdicts: list[ClaimVerdict]) -> str: return f"no - [Sanhedrin Veto] [{chosen.claim.claim_class}]: {reason}" +def recompute_legacy_from_result(result: dict[str, Any]) -> str: + vetoes = [] + for raw in result.get("verdicts", []): + claim = raw.get("claim", {}) if isinstance(raw, dict) else {} + status = str(raw.get("status", "")) + if status not in {"REFUTED", "REFUTED_BY_ABSENCE"}: + continue + vetoes.append( + ( + SEVERITY_ORDER.get(str(claim.get("claim_class", "")), 99), + int(claim.get("source_index", 0) or 0), + str(claim.get("claim_class", "TECHNICAL")), + truncate_chars(str(raw.get("reason") or claim.get("text") or ""), 140), + ) + ) + if not vetoes: + return "yes" + _, _, claim_class, reason = sorted(vetoes)[0] + return f"no - [Sanhedrin Veto] [{claim_class}]: {reason}" + + +def apply_appeals_to_claim_mode_result(result: dict[str, Any]) -> dict[str, Any]: + if sanhedrin_core is None: + return result + appeals = sanhedrin_core.load_appeals() + changed = False + for raw in result.get("verdicts", []): + if not isinstance(raw, dict) or raw.get("status") not in {"REFUTED", "REFUTED_BY_ABSENCE"}: + continue + claim = raw.get("claim", {}) if isinstance(raw.get("claim"), dict) else {} + text = str(claim.get("text") or "") + if sanhedrin_core.is_appealed({"fingerprint": sanhedrin_core.claim_fingerprint(text)}, appeals): + raw["status"] = "APPEALED" + raw["reason"] = "Prior appeal suppresses this Sanhedrin veto." + changed = True + + if changed: + legacy = recompute_legacy_from_result(result) + result["legacy_verdict"] = legacy + result["decision"] = "yes" if legacy == "yes" else "no" + result["verdict"] = result["decision"] + result["passed"] = legacy == "yes" + result["reason"] = "" if result["passed"] else legacy.split(" - ", 1)[-1] + return result + + +def save_claim_mode_receipt( + draft: str, + result: dict[str, Any], + manifest: dict[str, Any] | None = None, +) -> None: + if sanhedrin_core is None: + return + manifest = manifest or sanhedrin_core.new_manifest(draft) + claims = [] + for idx, raw in enumerate(result.get("verdicts", []), start=1): + if not isinstance(raw, dict): + continue + claim = raw.get("claim", {}) if isinstance(raw.get("claim"), dict) else {} + text = str(claim.get("text") or "") + claim_class = str(claim.get("claim_class") or "TECHNICAL") + status = str(raw.get("status") or "NEI") + evidence_ids = raw.get("evidence_ids") if isinstance(raw.get("evidence_ids"), list) else [] + if status == "SUPPORTED": + decision = "pass" + evidence_state = "supported" + fix = "No change required." + elif status == "APPEALED": + decision = "appealed" + evidence_state = "appealed" + fix = "Prior appeal suppresses this veto fingerprint." + elif status == "REFUTED_BY_ABSENCE": + decision = "veto" + evidence_state = "missing_precedent" + fix = "Remove the unsupported user-specific claim or cite durable Vestige evidence first." + elif status == "REFUTED": + decision = "veto" + evidence_state = "contradicted" + fix = "Remove or qualify the contradicted claim using the cited Vestige precedent." + else: + decision = "pass_unverified" + evidence_state = "not_enough_information" + fix = "No blocking change required." + claims.append( + { + "id": f"c{idx:03d}", + "text": text, + "fingerprint": sanhedrin_core.claim_fingerprint(text), + "class": claim_class, + "subject": "Sam" if bool(claim.get("sam_critical")) else "draft", + "risk": "hard" if bool(claim.get("sam_critical")) else "normal", + "evidence_state": evidence_state, + "decision": decision, + "precedent": [ + { + "type": "vestige", + "summary": str(raw.get("reason") or status), + "evidence": ", ".join(str(eid) for eid in evidence_ids[:5]), + "durableCount": raw.get("durable_evidence_count"), + "highTrustCount": raw.get("high_trust_evidence_count"), + } + ], + "fix": fix, + "appeal": { + "status": "appealed" if decision == "appealed" else "open", + "actions": ["stale", "wrong", "too_strict"], + }, + } + ) + + manifest["claims"] = claims + manifest["overall"] = "pass" if result.get("passed") else "veto" + if any(claim["decision"] == "appealed" for claim in claims): + manifest["overall"] = "pass_with_warnings" if result.get("passed") else manifest["overall"] + manifest["verdictBar"] = "APPEALED" + manifest["summary"] = "Prior appeal suppressed a Sanhedrin veto." + elif result.get("passed"): + manifest["verdictBar"] = "PASS" if not claims else "NOTE" + manifest["summary"] = "Sanhedrin found no blocking claim issues." + else: + manifest["verdictBar"] = "VETO" + manifest["summary"] = str(result.get("reason") or "Sanhedrin blocked a claim.") + sanhedrin_core.save_manifest(manifest) + + +def save_legacy_receipt(manifest: dict[str, Any] | None, verdict: str, evidence: str = "") -> str: + if sanhedrin_core is None or manifest is None: + return verdict + updated = sanhedrin_core.apply_model_verdict(manifest, verdict, evidence) + sanhedrin_core.save_manifest(manifest) + return updated + + def claim_mode_result(draft: str) -> dict[str, Any]: claims = extract_check_worthy_claims(draft) staged = load_staged_evidence(os.environ.get(STAGE_FILE_ENV)) @@ -1105,8 +1245,18 @@ def main() -> None: print("yes") return + manifest = sanhedrin_core.new_manifest(draft) if sanhedrin_core is not None else None + if sanhedrin_core is not None and manifest is not None: + receipt_veto = sanhedrin_core.apply_receipt_lock(manifest) + if receipt_veto: + sanhedrin_core.save_manifest(manifest) + print(f"no - [Sanhedrin Veto] [TECHNICAL]: {receipt_veto}") + return + if env_flag(CLAIM_MODE_ENV): - print_claim_mode_result(claim_mode_result(draft)) + result = apply_appeals_to_claim_mode_result(claim_mode_result(draft)) + save_claim_mode_receipt(draft, result, manifest) + print_claim_mode_result(result) return evidence, high_trust_count = fetch_evidence(draft) @@ -1115,6 +1265,7 @@ def main() -> None: # without something concrete to cite. Eliminates the common false-positive # mode where the model invents a contradiction from low-trust noise. if high_trust_count == 0: + save_legacy_receipt(manifest, "yes", evidence) print("yes") return @@ -1122,9 +1273,11 @@ def main() -> None: if not verdict: # Fail-open: server unreachable, malformed response, etc. + save_legacy_receipt(manifest, "yes", evidence) print("yes") return + verdict = save_legacy_receipt(manifest, verdict, evidence) print(verdict) diff --git a/hooks/sanhedrin.sh b/hooks/sanhedrin.sh index 49c5798..2802e08 100755 --- a/hooks/sanhedrin.sh +++ b/hooks/sanhedrin.sh @@ -30,7 +30,7 @@ load_vestige_sanhedrin_env() { command -v python3 >/dev/null 2>&1 || return 0 while IFS="$(printf '\t')" read -r key value; do case "$key" in - VESTIGE_SANHEDRIN_ENABLED|VESTIGE_SANHEDRIN_MODEL|VESTIGE_SANHEDRIN_ENDPOINT|VESTIGE_SANHEDRIN_CLAIM_MODE|VESTIGE_SANHEDRIN_OUTPUT|VESTIGE_SANHEDRIN_PYTHON|VESTIGE_DASHBOARD_PORT) + VESTIGE_SANHEDRIN_ENABLED|VESTIGE_SANHEDRIN_MODEL|VESTIGE_SANHEDRIN_ENDPOINT|VESTIGE_SANHEDRIN_CLAIM_MODE|VESTIGE_SANHEDRIN_OUTPUT|VESTIGE_SANHEDRIN_PYTHON|VESTIGE_SANHEDRIN_STATE_DIR|VESTIGE_SANHEDRIN_ALLOW_COMMAND_LEDGER|VESTIGE_DASHBOARD_PORT) export "$key=$value" ;; esac @@ -45,6 +45,8 @@ allowed = { "VESTIGE_SANHEDRIN_CLAIM_MODE", "VESTIGE_SANHEDRIN_OUTPUT", "VESTIGE_SANHEDRIN_PYTHON", + "VESTIGE_SANHEDRIN_STATE_DIR", + "VESTIGE_SANHEDRIN_ALLOW_COMMAND_LEDGER", "VESTIGE_DASHBOARD_PORT", } @@ -117,7 +119,7 @@ DRAFT_SCRIPT="$(mktemp -t vestige-sanhedrin-draft.XXXXXX)" trap 'rm -f "$DRAFT_SCRIPT"' EXIT cat > "$DRAFT_SCRIPT" <<'DRAFT_PYEOF' -import json, os, sys +import json, os, re, sys transcript = os.environ.get("TRANSCRIPT_PATH", "") last_assistant = "" @@ -146,21 +148,31 @@ try: except Exception: sys.exit(0) -# Print nothing if no draft or draft too short to contain a technical claim +# Print nothing if no draft. Short verification claims still need Receipt Lock. stripped = last_assistant.strip() -if not stripped or len(stripped) < 100: +if not stripped: sys.exit(0) # Legacy gate: only check drafts that contain technical indicators. Claim mode # deliberately broadens this to any substantive assistant draft while keeping # Sanhedrin opt-in through VESTIGE_SANHEDRIN_ENABLED. claim_mode = os.environ.get("VESTIGE_SANHEDRIN_CLAIM_MODE", "") == "1" +receipt_gate = bool( + re.search( + r"\b((all\s+)?(tests?|test suite|build|lint|typecheck|checks?|cargo test|npm test|pnpm test|pytest|vitest|jest|playwright|tsc|clippy)\s+(passed|passes|passing|green|succeeded|succeeds|clean)|(verified|validated|confirmed)\s+(with|by|via))\b", + stripped, + re.I, + ) +) +if len(stripped) < 100 and not receipt_gate: + sys.exit(0) + if not claim_mode: has_code = "`" in stripped or "```" in stripped has_cmd = any(kw in stripped.lower() for kw in ["install", "run ", "use ", "call ", "invoke", "execute"]) has_path = "/" in stripped and any(ext in stripped for ext in [".rs", ".ts", ".py", ".sh", ".md", ".json"]) - if not (has_code or has_cmd or has_path): + if not (has_code or has_cmd or has_path or receipt_gate): sys.exit(0) # Truncate to 4000 chars to keep Haiku prompt bounded @@ -190,6 +202,7 @@ fi # === SPAWN LOCAL EXECUTIONER (background with timeout) === OUTPUT_FILE="$(mktemp -t vestige-sanhedrin-out.XXXXXX)" trap 'rm -f "$DRAFT_SCRIPT" "$OUTPUT_FILE"' EXIT +export VESTIGE_SANHEDRIN_TRANSCRIPT="$TRANSCRIPT_PATH" ( printf '%s\n' "$DRAFT" | "$PYTHON_BIN" "$BRIDGE" > "$OUTPUT_FILE" 2>/dev/null @@ -225,6 +238,22 @@ sanhedrin_veto() { REASON="$1" REASON="$(printf '%s' "$REASON" | "$PYTHON_BIN" -c 'import sys; print(sys.stdin.read().strip())' 2>/dev/null || printf '%s' "$REASON")" + if printf '%s' "$REASON" | /usr/bin/grep -qi 'Receipt Lock'; then + cat >&2 <&2 < str: + return dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds") + + +def ensure_dirs() -> None: + RECEIPTS_DIR.mkdir(parents=True, exist_ok=True) + + +def stable_id(text: str, prefix: str = "sr") -> str: + digest = hashlib.sha256(text.encode("utf-8")).hexdigest()[:16] + return f"{prefix}_{digest}" + + +def claim_fingerprint(text: str) -> str: + normalized = re.sub(r"\s+", " ", text.lower()).strip() + normalized = re.sub(r"[`'\"$]", "", normalized) + return hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:16] + + +def split_claims(draft: str) -> list[str]: + chunks = re.split(r"(?<=[.!?])\s+|\n+", draft) + claims: list[str] = [] + for chunk in chunks: + text = chunk.strip(" -\t") + if len(text) >= 18 or VERIFICATION_RE.search(text) or is_hard_user_claim(text): + claims.append(text) + return claims[:24] + + +def detect_claim_type(text: str) -> str: + low = text.lower() + if VERIFICATION_RE.search(text): + return "receipt_lock" + if is_hard_user_claim(text): + return "hard_user_claim" + if any(word in low for word in ("won", "prize", "ranked", "placed", "score", "graduated", "worked at")): + return "hard_user_claim" + if any(word in low for word in ("should", "could", "recommend", "plan", "target", "estimate")): + return "advice" + if "`" in text or "/" in text or re.search(r"\bv?\d+\.\d+", text): + return "technical" + return "general" + + +def is_hard_user_claim(text: str) -> bool: + if not re.search(r"\b(Sam|you|your|I|my)\b", text, re.I): + return False + hard_patterns = ( + r"\b(attended|graduated|studied|enrolled|accepted|worked|works|employed|hired)\b", + r"\b(was\s+born|born\s+in|born\s+on|birthdate|birthday)\b", + r"\b(won|placed|ranked|scored|earned|raised|sold|founded|launched)\b", + r"\b(prize|award|payout|grant|scholarship|degree|gpa|employer|school|university|college|birth\s+date)\b", + r"\$[0-9]", + ) + return any(re.search(pattern, text, re.I) for pattern in hard_patterns) + + +def new_manifest(draft: str) -> dict[str, Any]: + draft_id = stable_id(draft, "draft") + claims = [] + for i, text in enumerate(split_claims(draft), start=1): + claim_type = detect_claim_type(text) + claims.append( + { + "id": f"c{i:03d}", + "text": text, + "fingerprint": claim_fingerprint(text), + "class": claim_type, + "subject": infer_subject(text), + "risk": "hard" if claim_type == "receipt_lock" else "normal", + "evidence_state": "unchecked", + "decision": "pending", + "precedent": [], + "fix": "", + "appeal": { + "status": "open", + "actions": ["stale", "wrong", "too_strict"], + }, + } + ) + return { + "schema": "vestige.sanhedrin.receipt.v1", + "id": stable_id(f"{draft_id}:{now_iso()}", "receipt"), + "draftId": draft_id, + "createdAt": now_iso(), + "overall": "pass", + "verdictBar": "PASS", + "summary": "No blocking claim issues found.", + "draftPreview": draft[:1000], + "claims": claims, + "receipts": [], + "source": { + "stateDir": str(STATE_DIR), + "transcript": os.environ.get("VESTIGE_SANHEDRIN_TRANSCRIPT"), + }, + } + + +def infer_subject(text: str) -> str: + if re.search(r"\b(Sam|you|your)\b", text, re.I): + return "Sam" + if re.search(r"\b(test|pytest|cargo test|npm test|pnpm test|vitest|jest)\b", text, re.I): + return "test receipt" + if re.search(r"\b(build|lint|typecheck|clippy|tsc)\b", text, re.I): + return "command receipt" + return "draft" + + +def command_families_for_claim(text: str) -> list[str]: + low = text.lower() + if re.search(r"\b(all\s+checks?|checks)\s+(passed|passes|passing|green|succeeded|succeeds|clean)\b", low) and "cargo check" not in low: + return ["test", "build", "lint", "typecheck"] + families: list[str] = [] + if any(word in low for word in ("test", "pytest", "vitest", "jest", "playwright")): + families.append("test") + if any(word in low for word in ("build", "compiled", "compile")): + families.append("build") + if any(word in low for word in ("lint", "clippy", "eslint", "ruff")): + families.append("lint") + if any(word in low for word in ("typecheck", "tsc", "mypy", "pyright", "cargo check")): + families.append("typecheck") + if "check" in low and "cargo check" not in low and "checks" not in low: + families.append("typecheck") + return families or ["test"] + + +def load_command_receipts() -> list[dict[str, Any]]: + transcript = os.environ.get("VESTIGE_SANHEDRIN_TRANSCRIPT") + if transcript: + return extract_transcript_receipts(Path(transcript)) + if os.environ.get("VESTIGE_SANHEDRIN_ALLOW_COMMAND_LEDGER") != "1": + return [] + return load_jsonl(COMMAND_RECEIPTS_JSONL) + + +def load_jsonl(path: Path) -> list[dict[str, Any]]: + if not path.exists(): + return [] + items: list[dict[str, Any]] = [] + try: + for line in path.read_text(encoding="utf-8").splitlines(): + line = line.strip() + if not line: + continue + obj = json.loads(line) + if isinstance(obj, dict): + items.append(obj) + except (OSError, json.JSONDecodeError): + return items + return items + + +def extract_transcript_receipts(path: Path) -> list[dict[str, Any]]: + if not path.exists(): + return [] + receipts: list[dict[str, Any]] = [] + pending_commands: dict[str, dict[str, Any]] = {} + try: + lines = path.read_text(encoding="utf-8", errors="ignore").splitlines() + except OSError: + return receipts + for line in lines: + try: + obj = json.loads(line) + except json.JSONDecodeError: + continue + receipts.extend(extract_structured_receipts(obj, pending_commands)) + blob = json.dumps(obj, ensure_ascii=False) + command = extract_command(blob) + if not command: + continue + exit_code = extract_exit_code(blob) + receipts.append( + { + "source": "transcript", + "command": command, + "exitCode": exit_code, + "success": exit_code == 0 if exit_code is not None else None, + "timestamp": obj.get("timestamp") or obj.get("created_at") or now_iso(), + } + ) + return receipts + + +def extract_structured_receipts( + obj: dict[str, Any], + pending_commands: dict[str, dict[str, Any]], +) -> list[dict[str, Any]]: + """Extract Claude Code Bash receipts from assistant tool_use/user tool_result pairs.""" + receipts: list[dict[str, Any]] = [] + timestamp = obj.get("timestamp") or obj.get("created_at") or now_iso() + receipts.extend(extract_codex_receipts(obj, pending_commands, timestamp)) + content = obj.get("message", {}).get("content", obj.get("content", "")) + + blocks = content if isinstance(content, list) else [] + for block in blocks: + if not isinstance(block, dict): + continue + if block.get("type") == "tool_use" and str(block.get("name", "")).lower() in {"bash", "shell", "exec_command"}: + tool_id = str(block.get("id") or "") + tool_input = block.get("input") if isinstance(block.get("input"), dict) else {} + command = str(tool_input.get("command") or tool_input.get("cmd") or "") + if tool_id and command: + pending_commands[tool_id] = { + "source": "transcript", + "toolUseId": tool_id, + "command": command, + "timestamp": timestamp, + } + if block.get("type") == "tool_result": + tool_id = str(block.get("tool_use_id") or "") + if not tool_id or tool_id not in pending_commands: + continue + receipt = dict(pending_commands[tool_id]) + text = stringify_tool_result(block) + explicit_exit = extract_exit_code(text) + is_error = bool(block.get("is_error")) + receipt["exitCode"] = explicit_exit if explicit_exit is not None else (1 if is_error else 0) + receipt["success"] = receipt["exitCode"] == 0 and not is_error + receipt["timestamp"] = timestamp + receipts.append(receipt) + + tool_result = obj.get("toolUseResult") + if isinstance(tool_result, dict): + command = str(obj.get("command") or tool_result.get("command") or "") + if command: + exit_code = tool_result.get("exitCode") + if exit_code is None: + exit_code = tool_result.get("exit_code") + try: + parsed_exit = int(exit_code) if exit_code is not None else None + except (TypeError, ValueError): + parsed_exit = extract_exit_code(json.dumps(tool_result, ensure_ascii=False)) + is_error = bool(tool_result.get("is_error") or tool_result.get("interrupted")) + receipts.append( + { + "source": "transcript", + "command": command, + "exitCode": parsed_exit if parsed_exit is not None else (1 if is_error else 0), + "success": (parsed_exit == 0 if parsed_exit is not None else not is_error), + "timestamp": timestamp, + } + ) + + return receipts + + +def extract_codex_receipts( + obj: dict[str, Any], + pending_commands: dict[str, dict[str, Any]], + timestamp: str, +) -> list[dict[str, Any]]: + receipts: list[dict[str, Any]] = [] + payload = obj.get("payload") + if not isinstance(payload, dict): + return receipts + + payload_type = payload.get("type") + name = str(payload.get("name") or "").lower() + call_id = str(payload.get("call_id") or "") + if payload_type == "function_call" and name in {"exec_command", "bash", "shell"} and call_id: + args = payload.get("arguments") + if isinstance(args, str): + try: + args = json.loads(args) + except json.JSONDecodeError: + args = {} + if isinstance(args, dict): + command = str(args.get("cmd") or args.get("command") or "") + if command: + pending_commands[call_id] = { + "source": "codex-transcript", + "toolUseId": call_id, + "command": command, + "timestamp": timestamp, + } + elif payload_type == "function_call" and name == "write_stdin" and call_id: + args = payload.get("arguments") + if isinstance(args, str): + try: + args = json.loads(args) + except json.JSONDecodeError: + args = {} + if isinstance(args, dict): + session_id = args.get("session_id") + session_receipt = pending_commands.get(f"session:{session_id}") + if session_receipt: + pending_commands[call_id] = dict(session_receipt) + + if payload_type == "function_call_output" and call_id in pending_commands: + receipt = dict(pending_commands[call_id]) + output = str(payload.get("output") or "") + running = re.search(r"Process running with session ID\s+(\d+)", output) + if running: + pending_commands[f"session:{running.group(1)}"] = receipt + return receipts + exit_code = extract_exit_code(output) + receipt["exitCode"] = exit_code + receipt["success"] = exit_code == 0 if exit_code is not None else None + receipt["timestamp"] = timestamp + receipts.append(receipt) + + return receipts + + +def stringify_tool_result(block: dict[str, Any]) -> str: + content = block.get("content", "") + if isinstance(content, str): + return content + return json.dumps(content, ensure_ascii=False) + + +def extract_command(blob: str) -> str | None: + for key in ("cmd", "command"): + match = re.search(rf'"{key}"\s*:\s*"([^"]+)"', blob) + if match: + return bytes(match.group(1), "utf-8").decode("unicode_escape") + match = CLAUDE_TOOL_NAME_RE.search(blob) + if match and match.group(1).lower() in {"bash", "shell", "exec_command"}: + return match.group(1) + return None + + +def extract_exit_code(blob: str) -> int | None: + match = COMMAND_EXIT_RE.search(blob) + if not match: + return None + try: + return int(match.group(2) or match.group(3) or match.group(4)) + except ValueError: + return None + + +def receipt_matches_family(receipt: dict[str, Any], family: str) -> bool: + command = str(receipt.get("command") or "") + pattern = COMMAND_FAMILY_PATTERNS.get(family) + return bool(pattern and pattern.search(command)) + + +def apply_receipt_lock(manifest: dict[str, Any]) -> str | None: + receipts = load_command_receipts() + manifest["receipts"] = receipts[-20:] + appeals = load_appeals() + + for claim in manifest["claims"]: + if claim["class"] != "receipt_lock": + continue + missing_families: list[str] = [] + failed_family: tuple[str, dict[str, Any]] | None = None + supported_families: list[tuple[str, dict[str, Any]]] = [] + + for family in command_families_for_claim(claim["text"]): + matching = [r for r in receipts if receipt_matches_family(r, family)] + latest = matching[-1] if matching else None + if latest is None: + missing_families.append(family) + elif latest.get("success") is not True: + failed_family = (family, latest) + break + else: + supported_families.append((family, latest)) + + if failed_family is not None: + family, latest = failed_family + claim["evidence_state"] = "failed_receipt" if latest.get("success") is False else "unknown_receipt" + claim["decision"] = "veto" + claim["precedent"].append( + { + "type": "command", + "summary": f"Latest {family} command did not produce a successful receipt.", + "command": latest.get("command"), + "exitCode": latest.get("exitCode"), + } + ) + claim["fix"] = f"Replace the claim with: I do not have a successful {family} receipt for this session." + manifest["overall"] = "veto" + manifest["verdictBar"] = "VETO" + manifest["summary"] = "Receipt Lock blocked a contradicted verification claim." + return f"Receipt Lock: Draft claims {family} passed, but latest {family} receipt is not successful." + + if missing_families and is_appealed(claim, appeals): + claim["evidence_state"] = "appealed" + claim["decision"] = "appealed" + claim["precedent"].append({"type": "appeal", "summary": "Prior appeal suppresses this missing-receipt veto."}) + manifest["overall"] = "pass_with_warnings" + manifest["verdictBar"] = "APPEALED" + manifest["summary"] = "Prior appeal suppressed a Receipt Lock veto." + continue + + if missing_families: + family_list = ", ".join(missing_families) + claim["evidence_state"] = "missing_receipt" + claim["decision"] = "veto" + claim["precedent"].append( + { + "type": "receipt_lock", + "summary": f"No {family_list} command receipt found in this session.", + "source": "transcript/command ledger", + } + ) + claim["fix"] = f"Replace the claim with: I do not have recorded {family_list} receipt(s) for this session." + manifest["overall"] = "veto" + manifest["verdictBar"] = "VETO" + manifest["summary"] = "Receipt Lock blocked an unsupported verification claim." + return f"Receipt Lock: Draft claims {family_list} passed, but no {family_list} command receipt exists." + + claim["evidence_state"] = "supported" + claim["decision"] = "pass" + for family, latest in supported_families: + claim["precedent"].append( + { + "type": "command", + "summary": f"{family} receipt found.", + "command": latest.get("command"), + "exitCode": latest.get("exitCode"), + } + ) + + return None + + +def apply_model_verdict(manifest: dict[str, Any], verdict: str, evidence: str = "") -> str: + low = verdict.strip().lower() + if low == "yes" or low.startswith("yes "): + if manifest["overall"] != "veto": + has_appealed = any(c["decision"] == "appealed" for c in manifest["claims"]) + has_unchecked = any(c["decision"] == "pending" for c in manifest["claims"]) + manifest["overall"] = "pass_with_warnings" if has_unchecked or has_appealed else "pass" + manifest["verdictBar"] = "APPEALED" if has_appealed else ("NOTE" if has_unchecked else "PASS") + manifest["summary"] = ( + "Prior appeal suppressed a Sanhedrin veto." + if has_appealed + else "Sanhedrin found no blocking contradiction." + ) + for claim in manifest["claims"]: + if claim["decision"] == "pending": + claim["decision"] = "pass_unverified" + claim["evidence_state"] = "out_of_scope" + return "yes" + + reason = verdict.split(" - ", 1)[1] if " - " in verdict else verdict + appeals = load_appeals() + candidate = first_relevant_claim(manifest) + if candidate and is_appealed(candidate, appeals): + candidate["decision"] = "appealed" + candidate["evidence_state"] = "appealed" + candidate["precedent"].append({"type": "appeal", "summary": "Prior appeal suppresses this model veto."}) + manifest["overall"] = "pass_with_warnings" + manifest["verdictBar"] = "APPEALED" + manifest["summary"] = "Prior appeal suppressed the Sanhedrin veto." + return "yes" + + if candidate: + candidate["decision"] = "veto" + candidate["evidence_state"] = "contradicted" + candidate["precedent"].append({"type": "vestige", "summary": reason[:500], "evidence": evidence[:1000]}) + candidate["fix"] = "Remove or qualify the contradicted claim using the cited Vestige precedent." + manifest["overall"] = "veto" + manifest["verdictBar"] = "VETO" + manifest["summary"] = reason[:500] + return verdict + + +def first_relevant_claim(manifest: dict[str, Any]) -> dict[str, Any] | None: + for claim in manifest["claims"]: + if claim["decision"] in {"pending", "pass_unverified"}: + return claim + return manifest["claims"][0] if manifest["claims"] else None + + +def load_appeals() -> list[dict[str, Any]]: + return load_jsonl(APPEALS_JSONL) + + +def is_appealed(claim: dict[str, Any], appeals: list[dict[str, Any]]) -> bool: + fp = claim.get("fingerprint") + if not fp: + return False + for appeal in appeals: + if ( + appeal.get("claimFingerprint") == fp + and appeal.get("reason") in {"stale", "wrong", "too_strict"} + and appeal.get("status", "active") == "active" + ): + return True + return False + + +def save_manifest(manifest: dict[str, Any]) -> None: + ensure_dirs() + receipt_path = RECEIPTS_DIR / f"{manifest['id']}.json" + html_path = RECEIPTS_DIR / f"{manifest['id']}.html" + json_blob = json.dumps(manifest, indent=2) + write_text_atomic(receipt_path, json_blob) + write_text_atomic(LATEST_JSON, json_blob) + rendered = render_receipt_html(manifest) + write_text_atomic(html_path, rendered) + write_text_atomic(LATEST_HTML, rendered) + + +def write_text_atomic(path: Path, content: str) -> None: + ensure_dirs() + tmp = path.with_name(f".{path.name}.{os.getpid()}.tmp") + tmp.write_text(content, encoding="utf-8") + tmp.replace(path) + + +def render_receipt_html(manifest: dict[str, Any]) -> str: + status = html.escape(str(manifest.get("verdictBar", "PASS"))) + summary = html.escape(str(manifest.get("summary", ""))) + claims = [] + for claim in manifest.get("claims", []): + precedents = "".join( + f"
    • {html.escape(str(p.get('summary', p)))}
      • " + for p in claim.get("precedent", []) + ) + claims.append( + "
      " + f"
      {html.escape(str(claim.get('decision')))} / {html.escape(str(claim.get('evidence_state')))}
      " + f"

      {html.escape(str(claim.get('text')))}

      " + f"

      Fix: {html.escape(str(claim.get('fix') or 'No change required.'))}

      " + f"

      Appeal: stale | wrong | too_strict

      " + f"
        {precedents}
      " + "
      " + ) + return f""" +Vestige Veto Receipt + +
      Verdict{status}
      +

      Veto Receipt

      {summary}

      {''.join(claims)} +""" + + +def appeal_latest(reason: str, note: str = "", claim_id: str | None = None) -> dict[str, Any]: + if not LATEST_JSON.exists(): + raise FileNotFoundError(str(LATEST_JSON)) + manifest = json.loads(LATEST_JSON.read_text(encoding="utf-8")) + claims = manifest.get("claims", []) + claim = next((c for c in claims if c.get("id") == claim_id), None) if claim_id else None + if claim is None: + claim = next((c for c in claims if c.get("decision") == "veto"), claims[0] if claims else None) + if claim is None: + raise ValueError("latest receipt has no claims") + appeal = { + "timestamp": now_iso(), + "receiptId": manifest.get("id"), + "claimId": claim.get("id"), + "claimFingerprint": claim.get("fingerprint"), + "claim": claim.get("text"), + "reason": reason, + "note": note, + "status": "active", + } + ensure_dirs() + with APPEALS_JSONL.open("a", encoding="utf-8") as f: + f.write(json.dumps(appeal) + "\n") + claim["appeal"]["status"] = "appealed" + claim["appeal"]["lastReason"] = reason + manifest["overall"] = "appealed" + manifest["verdictBar"] = "APPEALED" + manifest["summary"] = f"Appealed as {reason}." + save_manifest(manifest) + return appeal diff --git a/package.json b/package.json index dc84552..d72a5ad 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "vestige", - "version": "2.1.21", + "version": "2.1.22", "private": true, "description": "Cognitive memory for AI - MCP server with FSRS-6 spaced repetition", "author": "Sam Valladares", diff --git a/packages/vestige-init/package.json b/packages/vestige-init/package.json index 5325c4a..1c6ac04 100644 --- a/packages/vestige-init/package.json +++ b/packages/vestige-init/package.json @@ -1,6 +1,6 @@ { "name": "@vestige/init", - "version": "2.1.21", + "version": "2.1.22", "description": "Configure Vestige local memory for MCP-compatible AI agents", "bin": { "vestige-init": "bin/init.js" diff --git a/packages/vestige-mcp-npm/package.json b/packages/vestige-mcp-npm/package.json index 39bcb68..f51b5e1 100644 --- a/packages/vestige-mcp-npm/package.json +++ b/packages/vestige-mcp-npm/package.json @@ -1,6 +1,6 @@ { "name": "vestige-mcp-server", - "version": "2.1.21", + "version": "2.1.22", "mcpName": "io.github.samvallad33/vestige", "description": "Vestige MCP Server — local cognitive memory for MCP-compatible AI agents", "bin": { diff --git a/packages/vestige-mcpb/README.md b/packages/vestige-mcpb/README.md index 582c113..595dd58 100644 --- a/packages/vestige-mcpb/README.md +++ b/packages/vestige-mcpb/README.md @@ -4,7 +4,7 @@ One-click installation bundle for Claude Desktop. ## For Users -1. Download `vestige-2.1.21.mcpb` from [GitHub Releases](https://github.com/samvallad33/vestige/releases) +1. Download `vestige-2.1.22.mcpb` from [GitHub Releases](https://github.com/samvallad33/vestige/releases) 2. Double-click to install 3. Restart Claude Desktop @@ -34,5 +34,5 @@ vestige-mcpb/ │ ├── vestige-mcp-darwin-arm64 │ ├── vestige-mcp-linux-x64 │ └── vestige-mcp-win32-x64.exe -└── vestige-2.1.21.mcpb # Final bundle (generated) +└── vestige-2.1.22.mcpb # Final bundle (generated) ``` diff --git a/packages/vestige-mcpb/build.sh b/packages/vestige-mcpb/build.sh index eae32a7..cf48da8 100755 --- a/packages/vestige-mcpb/build.sh +++ b/packages/vestige-mcpb/build.sh @@ -1,7 +1,7 @@ #!/bin/bash set -euo pipefail -VERSION="${1:-2.1.21}" +VERSION="${1:-2.1.22}" REPO="samvallad33/vestige" TMPDIR="$(mktemp -d)" trap 'rm -rf "$TMPDIR"' EXIT diff --git a/packages/vestige-mcpb/manifest.json b/packages/vestige-mcpb/manifest.json index a1e2e67..690302d 100644 --- a/packages/vestige-mcpb/manifest.json +++ b/packages/vestige-mcpb/manifest.json @@ -2,7 +2,7 @@ "manifest_version": "0.2", "name": "vestige", "display_name": "Vestige", - "version": "2.1.21", + "version": "2.1.22", "description": "AI memory system built on 130 years of cognitive science. FSRS-6 spaced repetition, synaptic tagging, and local-first storage.", "author": { "name": "Sam Valladares", diff --git a/server.json b/server.json index 9bf97fb..d92c067 100644 --- a/server.json +++ b/server.json @@ -7,12 +7,12 @@ "url": "https://github.com/samvallad33/vestige", "source": "github" }, - "version": "2.1.21", + "version": "2.1.22", "packages": [ { "registryType": "npm", "identifier": "vestige-mcp-server", - "version": "2.1.21", + "version": "2.1.22", "transport": { "type": "stdio" } diff --git a/tests/hooks/test_sanhedrin_claim_mode.py b/tests/hooks/test_sanhedrin_claim_mode.py index 1996bc1..48efb22 100644 --- a/tests/hooks/test_sanhedrin_claim_mode.py +++ b/tests/hooks/test_sanhedrin_claim_mode.py @@ -41,6 +41,22 @@ class SanhedrinClaimModeTests(unittest.TestCase): def setUp(self): self.sanhedrin = load_sanhedrin() + @contextlib.contextmanager + def isolated_receipt_state(self): + with tempfile.TemporaryDirectory() as tmp: + state_dir = Path(tmp) + core = self.sanhedrin.sanhedrin_core + with patched_attr(core, "STATE_DIR", state_dir), patched_attr( + core, "RECEIPTS_DIR", state_dir / "receipts" + ), patched_attr(core, "LATEST_JSON", state_dir / "latest.json"), patched_attr( + core, "LATEST_HTML", state_dir / "latest.html" + ), patched_attr( + core, "APPEALS_JSONL", state_dir / "appeals.jsonl" + ), patched_attr( + core, "COMMAND_RECEIPTS_JSONL", state_dir / "command-receipts.jsonl" + ): + yield state_dir + def run_main(self, draft): stdin = io.StringIO(draft) stdout = io.StringIO() @@ -48,6 +64,54 @@ class SanhedrinClaimModeTests(unittest.TestCase): self.sanhedrin.main() return stdout.getvalue().strip() + def test_receipt_lock_blocks_unbacked_test_claim(self): + with self.isolated_receipt_state() as state_dir: + out = self.run_main("All tests passed.") + + self.assertIn("Receipt Lock", out) + receipt = json.loads((state_dir / "latest.json").read_text(encoding="utf-8")) + + self.assertEqual(receipt["verdictBar"], "VETO") + self.assertEqual(receipt["claims"][0]["decision"], "veto") + self.assertEqual(receipt["claims"][0]["evidence_state"], "missing_receipt") + + def test_receipt_lock_allows_matching_success_receipt(self): + with self.isolated_receipt_state() as state_dir, mock.patch.dict( + os.environ, {"VESTIGE_SANHEDRIN_ALLOW_COMMAND_LEDGER": "1"}, clear=False + ): + (state_dir / "command-receipts.jsonl").write_text( + json.dumps({ + "command": "cargo test --workspace --release", + "exitCode": 0, + "success": True, + }) + "\n", + encoding="utf-8", + ) + out = self.run_main("All tests passed.") + receipt = json.loads((state_dir / "latest.json").read_text(encoding="utf-8")) + + self.assertEqual(out, "yes") + self.assertNotEqual(receipt["verdictBar"], "VETO") + self.assertEqual(receipt["claims"][0]["decision"], "pass") + + def test_receipt_lock_appeal_suppresses_same_fingerprint(self): + with self.isolated_receipt_state() as state_dir: + fingerprint = self.sanhedrin.sanhedrin_core.claim_fingerprint("All tests passed.") + (state_dir / "appeals.jsonl").write_text( + json.dumps({ + "claimFingerprint": fingerprint, + "reason": "too_strict", + "status": "active", + }) + "\n", + encoding="utf-8", + ) + out = self.run_main("All tests passed.") + receipt = json.loads((state_dir / "latest.json").read_text(encoding="utf-8")) + + self.assertEqual(out, "yes") + self.assertEqual(receipt["verdictBar"], "APPEALED") + self.assertEqual(receipt["claims"][0]["decision"], "appealed") + def test_plain_sam_biographical_achievement_claim_is_check_worthy(self): claims = self.sanhedrin.extract_check_worthy_claims( "Sam graduated from Example University and won the Example AI Challenge." From a8550410b0a506aefd8eae7a321e68adc99e7e92 Mon Sep 17 00:00:00 2001 From: Luc Lauzon <128917870+randomnimbus@users.noreply.github.com> Date: Mon, 25 May 2026 12:49:51 -0600 Subject: [PATCH 04/23] feat(mcp): add per-tool _meta["anthropic/maxResultSizeChars"] annotation (#56) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Claude Code v2.1.91+ honors the per-tool annotation `_meta["anthropic/maxResultSizeChars"]` (up to 500_000) to override its 50K default truncation of `CallToolResult`. Without it, large Vestige payloads are silently truncated and spilled to disk, forcing the parent agent to chunk-read them. Empirically observed truncation under realistic default parameters (measured on v1.3.0 against ~3,300 memories; v2.x tool surface preserves the same names + payload shapes): search(detail_level="full", limit=20) -> 134,824 chars -> truncated search(detail_level="summary", limit=10) -> 71,318 chars -> truncated memory_timeline(limit=30) -> 83,626 chars -> truncated This patch: 1. Adds `meta: Option` to `ToolDescription` with `#[serde(rename = "_meta")]` so the wire shape matches the MCP spec. Backwards-compatible (the field is optional + `skip_serializing_if`; older MCP clients ignore unknown JSON keys per the spec). 2. Derives `Default` on `ToolDescription` so existing call sites can adopt the new field via struct-update syntax (`..Default::default()`) without restating it. 3. Annotates the four high-payload tools per measurement-driven discipline; the other 21 tools deliberately do NOT carry the annotation (cargo-cult prevention — a generous cap on every tool dilutes the signal and trains future maintainers that the value is arbitrary): - search -> 300_000 (2.2x headroom over observed peak) - memory_timeline -> 200_000 (2.4x headroom over observed peak) - memory -> 100_000 (single-record bounded) - codebase -> 100_000 (future-growth bounded) Tools that COULD plausibly grow into the annotated set with future workload (`deep_reference`, `cross_reference`, `memory_graph`, `explore_connections`, `session_context`) are left unannotated until empirical measurement shows truncation under realistic use. 4. Adds three regression tests in `server::tests`: - test_high_payload_tools_have_max_result_size_annotation: pins each cap value + asserts <= 500K Anthropic ceiling - test_other_tools_do_not_carry_max_result_size_annotation: cargo-cult prevention; dynamically iterates `tools/list` and asserts every tool NOT in the discipline-prescribed set lacks the annotation (robust to new tools being added by future PRs) - test_meta_wire_shape_uses_underscore_meta_field: pins the serde rename to `_meta` (the spec'd wire name) so a refactor of `ToolDescription` cannot silently drop the rename All 22 `server::tests` pass on v2.1.22 base (19 pre-existing + 3 new). Full lib test suite: 379/380 pass; the 1 unrelated failure (`tools::maintenance::tests::test_portable_export_writes_archive_to_storage_exports_dir`) is a pre-existing Windows path-separator assertion bug in `tools/maintenance.rs:823` (`path.ends_with("exports/portable-test.json")` fails on Windows where the path uses `\`) — unaffected by this PR. References: - Anthropic CC v2.1.91 release notes (April 2026): "Added MCP tool result persistence override via _meta['anthropic/maxResultSizeChars'] annotation (up to 500K), allowing larger results like DB schemas to pass through without truncation" - claude-agent-sdk-python v0.1.55 #756: forward bookkeeping establishing the on-Tool-definition (not on-CallToolResult) semantics for this annotation Co-authored-by: Peter Lauzon --- crates/vestige-mcp/src/protocol/messages.rs | 14 +- crates/vestige-mcp/src/server.rs | 202 +++++++++++++++++++- 2 files changed, 214 insertions(+), 2 deletions(-) diff --git a/crates/vestige-mcp/src/protocol/messages.rs b/crates/vestige-mcp/src/protocol/messages.rs index c58fa0a..8f7e459 100644 --- a/crates/vestige-mcp/src/protocol/messages.rs +++ b/crates/vestige-mcp/src/protocol/messages.rs @@ -82,13 +82,25 @@ pub struct ServerCapabilities { // ============================================================================ /// Tool description for tools/list -#[derive(Debug, Clone, Serialize, Deserialize)] +#[derive(Debug, Clone, Default, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub struct ToolDescription { pub name: String, #[serde(skip_serializing_if = "Option::is_none")] pub description: Option, pub input_schema: Value, + /// Per-tool `_meta` annotations from the MCP wire spec. + /// + /// Notable keys recognized by Claude Code (v2.1.91+): + /// - `anthropic/maxResultSizeChars` (integer, up to 500_000): + /// per-tool override of the 50K default `CallToolResult` truncation + /// ceiling. Pinned on the Tool definition; applies to every invocation. + /// + /// Free-form `serde_json::Value` (typically an object) so additional + /// vendor-specific `_meta` keys can be added without further schema + /// changes. + #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")] + pub meta: Option, } /// Result of tools/list diff --git a/crates/vestige-mcp/src/server.rs b/crates/vestige-mcp/src/server.rs index 2f0b457..a409ff5 100644 --- a/crates/vestige-mcp/src/server.rs +++ b/crates/vestige-mcp/src/server.rs @@ -227,7 +227,7 @@ impl McpServer { // v2.1.21: 25 tools (verified by the `tools.len() == 25` assertion in the // handle_tools_list test below — the `suppress` tool landed in v2.0.5). // Deprecated tools still work via redirects in handle_tools_call. - let tools = vec![ + let mut tools = vec![ // ================================================================ // UNIFIED TOOLS (v1.1+) // ================================================================ @@ -235,21 +235,25 @@ impl McpServer { name: "search".to_string(), description: Some("Unified search tool. Uses hybrid search (keyword + semantic + convex combination fusion) internally. Auto-strengthens memories on access (Testing Effect).".to_string()), input_schema: tools::search_unified::schema(), + ..Default::default() }, ToolDescription { name: "memory".to_string(), description: Some("Unified memory management tool. Actions: 'get' (retrieve full node), 'purge' (irreversibly remove content/embeddings with confirm=true), 'delete' (legacy alias for purge), 'state' (get accessibility state), 'promote' (thumbs up — increases retrieval strength), 'demote' (thumbs down — decreases retrieval strength, does NOT delete), 'edit' (update content in-place, preserves FSRS state).".to_string()), input_schema: tools::memory_unified::schema(), + ..Default::default() }, ToolDescription { name: "codebase".to_string(), description: Some("Unified codebase tool. Actions: 'remember_pattern' (store code pattern), 'remember_decision' (store architectural decision), 'get_context' (retrieve patterns and decisions).".to_string()), input_schema: tools::codebase_unified::schema(), + ..Default::default() }, ToolDescription { name: "intention".to_string(), description: Some("Unified intention management tool. Actions: 'set' (create), 'check' (find triggered), 'update' (complete/snooze/cancel), 'list' (show intentions).".to_string()), input_schema: tools::intention_unified::schema(), + ..Default::default() }, // ================================================================ // CORE MEMORY (v1.7: smart_ingest absorbs ingest + checkpoint) @@ -258,6 +262,7 @@ impl McpServer { name: "smart_ingest".to_string(), description: Some("INTELLIGENT memory ingestion with Prediction Error Gating. Single mode: provide 'content' to auto-decide CREATE/UPDATE/SUPERSEDE. Batch mode: provide 'items' array (max 20) for session-end saves — each item runs the full cognitive pipeline (importance scoring, intent detection, synaptic tagging).".to_string()), input_schema: tools::smart_ingest::schema(), + ..Default::default() }, // ================================================================ // TEMPORAL TOOLS (v1.2+) @@ -266,11 +271,13 @@ impl McpServer { name: "memory_timeline".to_string(), description: Some("Browse memories chronologically. Returns memories in a time range, grouped by day. Defaults to last 7 days.".to_string()), input_schema: tools::timeline::schema(), + ..Default::default() }, ToolDescription { name: "memory_changelog".to_string(), description: Some("View audit trail of memory changes. Per-memory: state transitions. System-wide: consolidations + recent state changes.".to_string()), input_schema: tools::changelog::schema(), + ..Default::default() }, // ================================================================ // MAINTENANCE TOOLS (v1.7: system_status replaces health_check + stats) @@ -279,26 +286,31 @@ impl McpServer { name: "system_status".to_string(), description: Some("Combined system health and statistics. Returns status (healthy/degraded/critical/empty), full stats, FSRS preview, cognitive module health, state distribution, warnings, and recommendations.".to_string()), input_schema: tools::maintenance::system_status_schema(), + ..Default::default() }, ToolDescription { name: "consolidate".to_string(), description: Some("Run FSRS-6 memory consolidation cycle. Applies decay, generates embeddings, and performs maintenance. Use when memories seem stale.".to_string()), input_schema: tools::maintenance::consolidate_schema(), + ..Default::default() }, ToolDescription { name: "backup".to_string(), description: Some("Create a SQLite database backup. Returns the backup file path.".to_string()), input_schema: tools::maintenance::backup_schema(), + ..Default::default() }, ToolDescription { name: "export".to_string(), description: Some("Export memories as JSON or JSONL. Supports tag and date filters.".to_string()), input_schema: tools::maintenance::export_schema(), + ..Default::default() }, ToolDescription { name: "gc".to_string(), description: Some("Garbage collect stale memories below retention threshold. Defaults to dry_run=true for safety.".to_string()), input_schema: tools::maintenance::gc_schema(), + ..Default::default() }, // ================================================================ // AUTO-SAVE & DEDUP TOOLS (v1.3+) @@ -307,11 +319,13 @@ impl McpServer { name: "importance_score".to_string(), description: Some("Score content importance using 4-channel neuroscience model (novelty/arousal/reward/attention). Returns composite score, channel breakdown, encoding boost, and explanations.".to_string()), input_schema: tools::importance::schema(), + ..Default::default() }, ToolDescription { name: "find_duplicates".to_string(), description: Some("Find duplicate and near-duplicate memory clusters using cosine similarity on embeddings. Returns clusters with suggested actions (merge/review). Use to clean up redundant memories.".to_string()), input_schema: tools::dedup::schema(), + ..Default::default() }, // ================================================================ // COGNITIVE TOOLS (v1.5+) @@ -320,16 +334,19 @@ impl McpServer { name: "dream".to_string(), description: Some("Trigger memory dreaming — replays recent memories to discover hidden connections, synthesize insights, and strengthen important patterns. Returns insights, connections, and dream stats.".to_string()), input_schema: tools::dream::schema(), + ..Default::default() }, ToolDescription { name: "explore_connections".to_string(), description: Some("Graph exploration tool for memory connections. Actions: 'chain' (build reasoning path between memories), 'associations' (find related memories via spreading activation + hippocampal index), 'bridges' (find connecting memories between two nodes).".to_string()), input_schema: tools::explore::schema(), + ..Default::default() }, ToolDescription { name: "predict".to_string(), description: Some("Proactive memory prediction — predicts what memories you'll need next based on context, recent activity, and learned patterns. Returns predictions, suggestions, and speculative retrievals.".to_string()), input_schema: tools::predict::schema(), + ..Default::default() }, // ================================================================ // RESTORE TOOL (v1.5+) @@ -338,6 +355,7 @@ impl McpServer { name: "restore".to_string(), description: Some("Restore memories from a JSON backup file. Supports MCP wrapper format, RecallResult format, and direct memory array format.".to_string()), input_schema: tools::restore::schema(), + ..Default::default() }, // ================================================================ // CONTEXT PACKETS (v1.8+) @@ -346,6 +364,7 @@ impl McpServer { name: "session_context".to_string(), description: Some("One-call session initialization. Combines search, intentions, status, predictions, and codebase context into a single token-budgeted response. Replaces 5 separate calls at session start.".to_string()), input_schema: tools::session_context::schema(), + ..Default::default() }, // ================================================================ // AUTONOMIC TOOLS (v1.9+) @@ -354,11 +373,13 @@ impl McpServer { name: "memory_health".to_string(), description: Some("Retention dashboard. Returns avg retention, retention distribution (buckets: 0-20%, 20-40%, etc.), trend (improving/declining/stable), and recommendation. Lightweight alternative to full system_status focused on memory quality.".to_string()), input_schema: tools::health::schema(), + ..Default::default() }, ToolDescription { name: "memory_graph".to_string(), description: Some("Subgraph export for visualization. Input: center_id or query, depth (1-3), max_nodes. Returns nodes with force-directed layout positions and edges with weights. Powers memory graph visualization.".to_string()), input_schema: tools::graph::schema(), + ..Default::default() }, // ================================================================ // DEEP REFERENCE (v2.0.4+) — replaces cross_reference @@ -367,16 +388,19 @@ impl McpServer { name: "deep_reference".to_string(), description: Some("Deep cognitive reasoning across memories. Combines FSRS-6 trust scoring, spreading activation, temporal supersession, dream insights, and contradiction analysis to build a complete understanding of a topic. Returns trust-scored evidence, fact evolution timeline, and a recommended answer. Use this when accuracy matters.".to_string()), input_schema: tools::cross_reference::schema(), + ..Default::default() }, ToolDescription { name: "cross_reference".to_string(), description: Some("Alias for deep_reference. Connect the dots across memories with cognitive reasoning.".to_string()), input_schema: tools::cross_reference::schema(), + ..Default::default() }, ToolDescription { name: "contradictions".to_string(), description: Some("Inspect memory disagreements directly. Scans a topic or recent memories for trust-weighted contradiction pairs using the same local logic as deep_reference.".to_string()), input_schema: tools::contradictions::schema(), + ..Default::default() }, // ================================================================ // ACTIVE FORGETTING (v2.0.5) — top-down suppression @@ -386,9 +410,47 @@ impl McpServer { name: "suppress".to_string(), description: Some("Actively suppress a memory via top-down inhibitory control (Anderson 2025 SIF + Davis Rac1). Distinct from delete: the memory persists but is inhibited from retrieval and actively decays. Each call compounds. A background Rac1 worker cascades decay to co-activated neighbors. Reversible within 24 hours via reverse=true.".to_string()), input_schema: tools::suppress::schema(), + ..Default::default() }, ]; + // Per-tool result-size annotation `_meta["anthropic/maxResultSizeChars"]`. + // + // Claude Code v2.1.91+ honors this annotation to override its 50K default + // `CallToolResult` truncation. Without it, large Vestige payloads + // (`search` with `detail_level="full"` at `limit=20` has been observed + // at ~135K chars; `memory_timeline` at `limit=30` at ~84K chars) are + // silently truncated and spilled to disk, forcing the parent agent to + // chunk-read them. + // + // Per-tool caps below are sized at ~2× observed peak with growth + // headroom; max permitted by Anthropic is 500_000. Only the four + // empirically-measured high-payload tools carry the annotation today; + // the remaining 21 tools deliberately do NOT (cargo-cult prevention — + // annotating a small-payload tool dilutes the signal). + // + // Other tools that COULD plausibly grow into the annotated set with + // future workload (`deep_reference`, `cross_reference`, `memory_graph`, + // `explore_connections`, `session_context`) are left unannotated until + // empirical measurement shows truncation under realistic use. + for tool in tools.iter_mut() { + let max_chars: Option = match tool.name.as_str() { + "search" => Some(300_000), + "memory_timeline" => Some(200_000), + "memory" => Some(100_000), + "codebase" => Some(100_000), + _ => None, + }; + if let Some(n) = max_chars { + let mut meta = serde_json::Map::new(); + meta.insert( + "anthropic/maxResultSizeChars".to_string(), + serde_json::Value::from(n), + ); + tool.meta = Some(serde_json::Value::Object(meta)); + } + } + let result = ListToolsResult { tools }; serde_json::to_value(result).map_err(|e| JsonRpcError::internal_error(&e.to_string())) } @@ -1899,4 +1961,142 @@ mod tests { assert!(response.error.is_some()); assert_eq!(response.error.unwrap().code, -32602); } + + // ======================================================================== + // Per-tool result-size annotation tests + // (`_meta["anthropic/maxResultSizeChars"]`, CC v2.1.91+) + // + // The annotation lives on the Tool definition in `tools/list`, so CC reads + // it once when the MCP session opens and applies the override to every + // invocation of that tool. These tests pin the wire-form so a future + // refactor of `ToolDescription` cannot silently drop the annotation. + // ======================================================================== + + /// Expected per-tool caps. Returns `Some(cap)` for tools the discipline + /// annotates, `None` for tools that MUST NOT carry the annotation + /// (cargo-cult prevention). + fn expected_max_result_size(name: &str) -> Option { + match name { + "search" => Some(300_000), + "memory_timeline" => Some(200_000), + "memory" => Some(100_000), + "codebase" => Some(100_000), + _ => None, + } + } + + #[tokio::test] + async fn test_high_payload_tools_have_max_result_size_annotation() { + let (mut server, _dir) = test_server().await; + let init_request = make_request("initialize", Some(init_params())); + server.handle_request(init_request).await; + + let request = make_request("tools/list", None); + let response = server.handle_request(request).await.unwrap(); + let result = response.result.unwrap(); + let tools = result["tools"].as_array().unwrap(); + + for name in ["search", "memory_timeline", "memory", "codebase"] { + let tool = tools + .iter() + .find(|t| t["name"].as_str() == Some(name)) + .unwrap_or_else(|| panic!("Tool '{}' missing from tools/list", name)); + + let expected = expected_max_result_size(name).unwrap(); + let meta = tool.get("_meta").unwrap_or_else(|| { + panic!("Tool '{}' is missing the `_meta` field on the wire", name) + }); + let actual = meta + .get("anthropic/maxResultSizeChars") + .and_then(|v| v.as_u64()) + .unwrap_or_else(|| { + panic!( + "Tool '{}' _meta lacks integer 'anthropic/maxResultSizeChars'", + name + ) + }); + assert_eq!( + actual, expected, + "Tool '{}' cap drift: expected {} got {}", + name, expected, actual + ); + assert!( + actual <= 500_000, + "Tool '{}' cap {} exceeds Anthropic 500K ceiling", + name, + actual + ); + } + } + + #[tokio::test] + async fn test_other_tools_do_not_carry_max_result_size_annotation() { + // Cargo-cult prevention. Dynamically derived from tools/list so this + // test is robust to new tools being added: any tool that is NOT in + // the discipline-prescribed set MUST NOT carry the annotation. + // Adding the annotation to a small-payload tool dilutes the signal + // and trains future maintainers that the value is arbitrary. + let (mut server, _dir) = test_server().await; + let init_request = make_request("initialize", Some(init_params())); + server.handle_request(init_request).await; + + let request = make_request("tools/list", None); + let response = server.handle_request(request).await.unwrap(); + let result = response.result.unwrap(); + let tools = result["tools"].as_array().unwrap(); + + for tool in tools { + let name = tool["name"].as_str().unwrap(); + if expected_max_result_size(name).is_some() { + continue; // covered by the annotated-tools test + } + + // Either the `_meta` key is absent OR it is an object without the + // anthropic key — both are acceptable. The forbidden case is the + // anthropic key present on this tool. + let has_max_size = tool + .get("_meta") + .and_then(|m| m.get("anthropic/maxResultSizeChars")) + .is_some(); + assert!( + !has_max_size, + "Tool '{}' should NOT carry maxResultSizeChars annotation \ + (not in the discipline-prescribed set: search, memory_timeline, \ + memory, codebase). If this tool's realistic max-payload now \ + routinely exceeds 50K, update expected_max_result_size() + the \ + annotation loop in handle_tools_list together.", + name + ); + } + } + + #[tokio::test] + async fn test_meta_wire_shape_uses_underscore_meta_field() { + // Anthropic's MCP spec is explicit: the field on the wire is `_meta`, + // NOT `meta`. The Rust struct uses `meta: Option` with + // `#[serde(rename = "_meta")]` — assert the rename actually fired. + let (mut server, _dir) = test_server().await; + let init_request = make_request("initialize", Some(init_params())); + server.handle_request(init_request).await; + + let request = make_request("tools/list", None); + let response = server.handle_request(request).await.unwrap(); + let result = response.result.unwrap(); + let tools = result["tools"].as_array().unwrap(); + + let search_tool = tools + .iter() + .find(|t| t["name"].as_str() == Some("search")) + .expect("'search' tool present"); + + // Wire-form: `_meta` must exist; `meta` (un-renamed) must NOT exist. + assert!( + search_tool.get("_meta").is_some(), + "search tool missing `_meta` key (serde rename to _meta did not apply)" + ); + assert!( + search_tool.get("meta").is_none(), + "search tool has un-renamed `meta` key (regression — serde rename broke)" + ); + } } From c584ec8afeb8a82b9659b2c1fc36fc900f997c4b Mon Sep 17 00:00:00 2001 From: Jan De Landtsheer Date: Wed, 27 May 2026 09:35:23 +0200 Subject: [PATCH 05/23] docs(adr): add ADR 0002 -- Phase 2 execution Binding ADR for Phase 2 Postgres backend integration plus the Phase 1 amendment that removes async_trait from the storage and embedder traits. Decisions D1-D8: - D1: sunset async_trait across MemoryStore + Embedder via trait_variant - D2: PgMemoryStore::connect(url, max_connections) mirrors SqliteMemoryStore; no Embedder in constructor; register_model handles pgvector typmod - D3: split sqlite.rs into a sqlite/ directory as Phase 1 amendment - D4: postgres/ as a directory from day one - D5: sub-plan layout -- 3 Phase 1 amendment + 9 Phase 2 sub-plans - D6: no separate ADR for the SQLite split (pure code motion) - D7: reserve multi-tenancy schema (users/groups/group_memberships + owner_user_id/visibility/shared_with_groups) in Phase 2 so Phase 3 auth is additive, not an online migration over an HNSW-indexed table - D8: codebase promoted to a first-class indexed column on knowledge_nodes; mcp_client_id and session_id stay in metadata JSONB PR cadence: PR A = Phase 1 amendment (code on feat/storage-trait-phase1); PR B = this ADR + Phase 2 sub-plans (docs only); PR C = Phase 2 implementation. Phase 4 sharing_rules table sketched in Follow-ups. --- docs/adr/0002-phase-2-execution.md | 545 +++++++++++++++++++++++++++++ 1 file changed, 545 insertions(+) create mode 100644 docs/adr/0002-phase-2-execution.md diff --git a/docs/adr/0002-phase-2-execution.md b/docs/adr/0002-phase-2-execution.md new file mode 100644 index 0000000..6b6949f --- /dev/null +++ b/docs/adr/0002-phase-2-execution.md @@ -0,0 +1,545 @@ +# ADR 0002: Phase 2 Execution -- Postgres Backend Integration, Phase 1 Amendment + +**Status**: Accepted +**Date**: 2026-05-26 +**Related**: [docs/adr/0001-pluggable-storage-and-network-access.md](0001-pluggable-storage-and-network-access.md), [docs/plans/0002-phase-2-postgres-backend.md](../plans/0002-phase-2-postgres-backend.md) + +--- + +## Context + +ADR 0001 set the architectural direction: introduce `MemoryStore` and `Embedder` +traits, ship a Postgres backend behind a feature flag, and reach a single shared +memory brain across machines. Phase 1 (storage trait extraction) shipped on +`feat/storage-trait-phase1` (790c0c8). The Phase 2 master plan at +`docs/plans/0002-phase-2-postgres-backend.md` was drafted before Phase 1 was +frozen. + +Starting Phase 2 surfaces a small set of execution-level decisions that ADR 0001 +did not cover and that the master plan now disagrees with the live code on. +These decisions are too big to silently absorb into a per-step plan and too +small to amend ADR 0001. They live here. + +Three concrete realities driving this ADR: + +1. **Trait shape mismatch.** Master plan 0002 assumed `trait_variant::make` + produced distinct `MemoryStore` (Send-bound) and `LocalMemoryStore` + (non-Send) variants, and that errors were `StoreError`. Phase 1 froze on + `#[async_trait::async_trait]` with `pub use MemoryStore as LocalMemoryStore` + and an error type called `MemoryStoreError`. The Postgres backend has to + follow Phase 1, not the master plan -- but we should record that explicitly. +2. **`SqliteMemoryStore` is monolithic.** + `crates/vestige-core/src/storage/sqlite.rs` is ~8200 lines. Phase 1 appended + the trait impl block at the bottom of the same file. Adding a similarly + large `postgres.rs` perpetuates the pattern; this is the natural moment to + decide whether the SQLite file gets split. +3. **Constructor surface drift.** Master plan 0002 specifies + `PgMemoryStore::connect(url, max_connections, &dyn Embedder)`. The Phase 1 + `SqliteMemoryStore` constructor takes no embedder -- registry consistency + runs through `registered_model()` / `register_model()` on the trait, + invoked by the caller. The two backends should look the same to a caller; + right now they would not. +4. **Multi-tenancy is a one-way door.** The Postgres schema is the place to + reserve user/group/visibility columns *now*, even though Phase 3 is the + phase that wires the auth filter using them. Adding `owner_user_id` and + GIN indexes to a populated, HNSW-indexed `knowledge_nodes` table later is an + expensive online migration; reserving NULL-defaulted columns at schema + creation is ~10 lines of SQL. The same logic applies to per-memory + context capture (codebase, MCP caller, session) -- promoting `codebase` + to a first-class column now keeps the door open for context-aware + sharing rules in Phase 4 without touching `knowledge_nodes`. See D7 and D8. + +This ADR is also the umbrella under which Phase 2 sub-plans (`0002a-...`, +`0002b-...`, etc.) sit. The intent is: ADR + sub-plans land as one PR for +review; the implementation lands as a second PR with many commits inside. + +--- + +## Already Decided (carried in by reference) + +These are settled by ADR 0001 or by explicit agreement during this session. +Listed here so the discussion frame is clear; not re-litigated below. + +- Postgres backend ships behind a `postgres-backend` Cargo feature, default + OFF. Mutually compilable with SQLite. (ADR 0001.) +- Single big `MemoryStore` trait. `PgMemoryStore` implements the same surface + as `SqliteMemoryStore`. (ADR 0001.) +- pgvector HNSW + tsvector + GIN + RRF hybrid search in one SQL statement. + (Master plan 0002, D4-D5.) +- sqlx 0.8 + pgvector 0.4 + compile-time-checked queries + offline `.sqlx/` + cache committed. (Master plan 0002.) +- Two sqlx migration files: `0001_init` (extensions, tables, non-vector + indexes) and `0002_hnsw` (HNSW separated for re-embed drop/recreate). + (Master plan 0002, D4.) +- `vestige migrate --from sqlite --to postgres` and + `vestige migrate --reembed --model=` CLI subcommands. (ADR 0001 + + master plan 0002, D8-D10.) +- PR cadence: PR #1 carries this ADR plus all sub-plans; PR #2 carries the + implementation as many commits. +- Sub-plans use `0002a-`, `0002b-`, ... suffixes off `0002-`. +- `PgMemoryStore::connect` lands as `todo!()` in the skeleton; real body + comes later. + +--- + +## Decisions + +### D1. Sunset async_trait across the Phase 1 traits + +Phase 1 froze with `#[async_trait::async_trait]` on both the `MemoryStore` +trait (`storage/memory_store.rs:194`) and the `Embedder` trait +(`embedder/mod.rs:27`), plus their SQLite and Fastembed impl blocks. async_trait +boxes every async fn into `Pin>` -- one heap allocation +per call inside the hottest code path. We are amending Phase 1 to remove +async_trait entirely and replace it with `trait_variant::make`, so each trait +becomes two real generated variants (`MemoryStore` / `LocalMemoryStore`, +`Embedder` / `LocalEmbedder`) with `Send` bounds on the outer variant. + +Scope split across three Phase 1 amendment sub-plans: + +- **`0001a-trait-rewrite.md`** -- Rewrite `MemoryStore` only. Touches + `storage/memory_store.rs` (trait declaration) and `storage/sqlite.rs` + (impl block attribute). Leaves async_trait in place on the embedder side + so the diff stays focused. +- **`0001b-sqlite-split.md`** -- Pure code motion. Splits the + ~8200-line `sqlite.rs` into a `sqlite/` directory. Independent of D1; can + land in either order relative to `0001a`. +- **`0001c-async-trait-sunset.md`** -- Rewrite `Embedder` the same way, then + remove `async-trait = "0.1"` from `crates/vestige-core/Cargo.toml`. Final + amendment commit removes the dependency entirely. After this lands, the + workspace contains zero references to `async_trait`. + +All three sub-plans land on the existing `feat/storage-trait-phase1` branch +(790c0c8 has not been opened upstream yet; amend in place, no force-push to a +public PR). + +### D2. PgMemoryStore::connect mirrors SqliteMemoryStore::new + +```rust +impl PgMemoryStore { + pub async fn connect(url: &str, max_connections: u32) -> MemoryStoreResult; + pub async fn from_pool(pool: PgPool) -> MemoryStoreResult; +} +``` + +No `Embedder` in the constructor. The pgvector-specific +`ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector($N)` DDL lives +inside the trait method `register_model(&ModelSignature)`. That method is +called by the caller (cognitive engine bootstrap, migrate CLI, tests) after +construction, exactly as it is for `SqliteMemoryStore`. + +`MemoryStoreError` gains two variants behind the feature flag (added during +the Postgres impl, not during the Phase 1 amendment): +```rust +#[cfg(feature = "postgres-backend")] +#[error("postgres error: {0}")] +Postgres(#[from] sqlx::Error), + +#[cfg(feature = "postgres-backend")] +#[error("postgres migration error: {0}")] +Migrate(#[from] sqlx::migrate::MigrateError), +``` + +### D3. Split sqlite.rs into a sqlite/ directory as Phase 1 amendment + +Pure code motion, no behavioural change. Target layout: +``` +crates/vestige-core/src/storage/sqlite/ + mod.rs -- SqliteMemoryStore struct, new(), reader/writer locks + crud.rs -- insert/get/update/delete + search.rs -- fts_search, vector_search, hybrid search + scheduling.rs -- FSRS state methods + graph.rs -- edges, neighbors + domain.rs -- domain CRUD, classify stub + registry.rs -- embedding_model table + register_model + portable_sync.rs -- portable archive backend bridge + trait_impl.rs -- impl LocalMemoryStore for SqliteMemoryStore +``` + +Cognitive-module imports stay on `crate::storage::SqliteMemoryStore` and +related re-exports from `storage/mod.rs`; the split is private to the +module. Each motion commit must keep `cargo test -p vestige-core` green for +bisectability. + +This lands in the Phase 1 amendment PR alongside D1 (separate commit, same +branch). + +### D4. Postgres backend as a directory from day one + +``` +crates/vestige-core/src/storage/postgres/ + mod.rs -- PgMemoryStore struct, connect, from_pool, trait impl + pool.rs -- PgPool construction from PostgresConfig + migrations.rs -- sqlx::migrate! wrapper + registry.rs -- ensure_registry, ALTER COLUMN TYPE vector(N) + search.rs -- RRF query + row mapping + migrate_cli.rs -- SQLite -> Postgres streaming copy + reembed.rs -- O(n) re-encode + HNSW rebuild +``` + +D1+D2 of the master plan land first as a skeleton in `mod.rs` with `todo!()` +bodies; later sub-plans fill in the other files. + +### D5. Sub-plan layout: two phases worth of sub-plans + +Phase 1 amendment sub-plans (under `docs/plans/`): +- `0001a-trait-rewrite.md` -- MemoryStore async_trait -> trait_variant, call-site audit +- `0001b-sqlite-split.md` -- sqlite.rs -> sqlite/ directory, commit-by-commit +- `0001c-async-trait-sunset.md` -- Embedder rewrite + drop async-trait dep from Cargo.toml + +Phase 2 sub-plans (under `docs/plans/`): +- `0002a-skeleton-and-feature-gate.md` -- master plan D1 + D2 (todo!() bodies) +- `0002b-pool-and-config.md` -- master plan D3 + D7 +- `0002c-migrations.md` -- master plan D4 +- `0002d-store-impl-bodies.md` -- master plan D2 real bodies + D6 registry +- `0002e-hybrid-search.md` -- master plan D5 +- `0002f-migrate-cli.md` -- master plan D8 + D10 +- `0002g-reembed.md` -- master plan D9 +- `0002h-testing-and-benches.md` -- master plan D14 + D15 +- `0002i-runbook.md` -- master plan D16 + +Each sub-plan is a self-contained brief sized to fit one focused +implementation session (handed to Claude Code as a `/goal` instruction +without requiring the agent to load the master plan). + +### D6. SQLite split does not get its own ADR + +The split is pure code motion; no public types, behaviour, or paths change. +`0001b-sqlite-split.md` is enough. + +### D7. Multi-tenancy schema reservation (L1-L3) + +Phase 2 reserves the columns and tables needed for future per-user / per-group +visibility, so Phase 3 (auth) does not require a column-add migration over a +populated, HNSW-indexed `knowledge_nodes` table. Single-user behaviour is unchanged +in both backends. + +New tables in `0001_init.up.sql`: + +```sql +CREATE TABLE users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + handle TEXT NOT NULL UNIQUE, + display_name TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb +); + +CREATE TABLE groups ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + handle TEXT NOT NULL UNIQUE, + display_name TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb +); + +CREATE TABLE group_memberships ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, + role TEXT NOT NULL DEFAULT 'member', -- 'member' | 'admin' + joined_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, group_id) +); + +INSERT INTO users (id, handle, display_name) + VALUES ('00000000-0000-0000-0000-000000000001', 'local', 'Local User'); +``` + +New columns on `knowledge_nodes`: + +```sql +owner_user_id UUID NOT NULL DEFAULT '00000000-0000-0000-0000-000000000001' + REFERENCES users(id), +visibility TEXT NOT NULL DEFAULT 'private', -- 'private' | 'group' | 'public' +shared_with_groups UUID[] NOT NULL DEFAULT '{}' + +CREATE INDEX idx_knowledge_nodes_owner ON knowledge_nodes (owner_user_id); +CREATE INDEX idx_knowledge_nodes_shared_groups ON knowledge_nodes USING GIN (shared_with_groups); +``` + +Phase 3 visibility filter (declared here for reference; implemented in Phase 3): + +```sql +WHERE + (visibility = 'private' AND owner_user_id = $me) + OR (visibility = 'group' + AND (owner_user_id = $me OR shared_with_groups && $my_group_ids)) + OR visibility = 'public' +``` + +Why tri-state enum and not just `shared_with_groups[] + is_public`: the +explicit `visibility` field documents intent at the row level. A `'private'` +row with a non-empty `shared_with_groups` is detectable inconsistency +(a CHECK constraint can enforce it later) rather than silent data. + +SQLite parity: same tables and columns with identical defaults. +`shared_with_groups` is a JSON `'[]'` text encoding (no array type). +Single-user mode never changes any of these values; the trait surface ignores +the visibility filter for SQLite because there is exactly one user. + +Sharing automation (matching by domain, tag, repo, MCP caller, ...) is +explicitly **not** in Phase 2. See D8 for context capture, and the Follow-ups +section for the Phase 4 `sharing_rules` design sketch. + +RLS policies are not declared in Phase 2. Phase 3 decides whether to add +RLS as defense-in-depth on top of the app-layer filter. + +### D8. Context-aware ingest + +Every memory carries its ingest context, so future automation (sharing rules, +domain scoping, audit) can match on it without a schema migration. Most of +this is already happening in the Phase 1 ingest pipeline; D8 promotes it to +ADR-level commitment so Phase 2 cannot drop it on the way to Postgres. + +Context dimensions and where they live: + +- **`codebase`** -- promoted to a first-class indexed column on `knowledge_nodes`. + High-frequency query path (`SELECT ... WHERE codebase = 'vestige'`) for + both human exploration and Phase 4 HDBSCAN scoping. Direct B-tree index + beats JSONB extraction. + ```sql + codebase TEXT, -- nullable; populated from ingest context + CREATE INDEX idx_knowledge_nodes_codebase ON knowledge_nodes (codebase) WHERE codebase IS NOT NULL; + ``` + `MemoryRecord` gains `pub codebase: Option`. + +- **`mcp_client_id`** -- which MCP caller created this. Persistent identity + once Phase 3 API keys exist. Lives in `metadata.mcp_client_id` (JSONB). + Not query-hot enough to deserve a column. + +- **`session_id`** -- ephemeral; identifies the calling session for runtime + override scoping. Lives in `metadata.session_id` (JSONB). Sessions die + fast; storing them as rows or indexed columns is waste. + +- **`file` / `topics`** -- existing optional context already accepted by the + ingest pipeline. Stay in metadata JSONB. + +Phase 2's job for D8 is operational, not architectural: audit the ingest +path from MCP request to row write to ensure none of these fields gets +dropped when crossing the SQLite -> Postgres backend boundary. + +--- + +## PR Cadence + +Two work streams, three PRs total: + +1. **PR A: Phase 1 amendment** + - Branch: `feat/storage-trait-phase1` (existing, amended in place) + - Commits: MemoryStore trait rewrite (0001a) + sqlite split (0001b, multiple + motion commits) + Embedder rewrite & async-trait dep removal (0001c). + - Sub-plans `0001a-`, `0001b-`, `0001c-` are committed on this branch. + +2. **PR B: ADR 0002 + Phase 2 sub-plans (this document + the 9 sub-plans)** + - New branch off PR A's tip once that is reviewed. + - No code; docs only. + +3. **PR C: Phase 2 implementation** + - New branch off PR B's tip. + - One PR with many commits clustered by sub-plan. + +PR B is the "let's discuss execution before writing code" gate. PR C is the +"now we write code" gate. If PR A is itself sizable enough that it needs the +amendments reviewed in stages, the three sub-plans (`0001a`, `0001b`, `0001c`) +can split into separate PRs; that's a tactical call at PR time. + +--- + +## Architecture Overview + +Final layout after the Phase 1 amendment (PR A) and Phase 2 implementation +(PR C): + +``` +crates/vestige-core/src/storage/ + mod.rs -- re-exports, Storage alias for BC + memory_store.rs -- trait_variant-generated MemoryStore + LocalMemoryStore, types, error + migrations.rs -- SQLite migration registry (Phase 1, unchanged) + portable.rs -- portable archive format (Phase 1, unchanged) + sqlite/ -- was sqlite.rs (D3, Phase 1 amendment) + mod.rs -- SqliteMemoryStore struct, new(), reader/writer locks + crud.rs -- insert/get/update/delete + search.rs -- fts/vector/hybrid + scheduling.rs -- FSRS state + graph.rs -- edges, neighbors + domain.rs -- domain CRUD, classify stub + registry.rs -- embedding_model table + register_model + portable_sync.rs -- portable backend bridge + trait_impl.rs -- impl LocalMemoryStore for SqliteMemoryStore + postgres/ -- D4, Phase 2 + mod.rs -- PgMemoryStore struct, connect, from_pool, trait impl + pool.rs -- PgPool construction from config + migrations.rs -- sqlx::migrate! wrapper + registry.rs -- register_model body, ALTER COLUMN TYPE vector(N) + search.rs -- RRF query + row mapping + migrate_cli.rs -- SQLite -> Postgres streaming copy + reembed.rs -- O(n) re-encode + HNSW rebuild + +crates/vestige-core/migrations/ + sqlite/ -- Phase 1, with V15 migration for D7+D8 columns/tables + postgres/ -- Phase 2 + 0001_init.up.sql -- includes D7 tables + columns, D8 codebase column + 0001_init.down.sql + 0002_hnsw.up.sql + 0002_hnsw.down.sql +``` + +Tables in the Postgres schema after migration 0001: + +| Table | Purpose | Phase that populates | +|-------|---------|----------------------| +| `embedding_model` | One-row registry of name/dim/hash | Phase 2 (first connect) | +| `knowledge_nodes` | Core records + owner/visibility/codebase | Phase 2 ingest; Phase 4 fills `domains` | +| `scheduling` | FSRS state | Phase 2 | +| `edges` | Spreading activation graph | Phase 2 | +| `review_events` | Append-only FSRS review log | Phase 2; Phase 5 federation reads | +| `domains` | Phase 4 cluster centroids | Phase 4 | +| `users` | L1 identities (D7) | Phase 3 | +| `groups` | L3 groups (D7) | Phase 3 | +| `group_memberships` | L3 user-group links (D7) | Phase 3 | + +`sharing_rules` (Phase 4) and `api_keys` (Phase 3) are added later by their +own migrations. + +--- + +## Alternatives Considered + +| Alternative | Why not | +|-------------|---------| +| Keep async_trait on the Phase 1 trait | One heap allocation per trait call inside the hottest code path in Vestige. Boxing every future also obscures the actual return type, which makes lifetimes and Send-ness harder to reason about. The Phase 1 PR is not opened upstream yet, so amending is free. | +| Take `&dyn Embedder` into `connect` | Couples constructor to embedder; breaks ADR 0001's separation; can't be used by callers that don't have an embedder yet (tests, migrate CLI). | +| Defer SQLite split | Postgres lands alongside an 8K-line peer; the pattern compounds; future readers see "backends are huge here". | +| Single `postgres.rs` | Master plan calls out 7 sub-files; we know it's getting split; doing it twice is waste. | +| Per-deliverable sub-plans (16 docs) | Review fatigue; many sub-plans would be 3-5 lines of Cargo or one migration each. Logical groups cluster naturally with PR commits. | +| One rolling sub-plan with checkboxes | Moving target; doesn't serve as a `/goal` brief for a fresh Claude Code session. | +| Separate ADR for the SQLite split | Pure code motion with no public-surface change; doesn't constrain future decisions. ADRs are for decisions that bind. | +| Punt multi-tenancy schema entirely to Phase 3 | Adding `owner_user_id` and indexes to a populated, HNSW-indexed `knowledge_nodes` table later is an expensive online migration. Reserving NULL-defaulted columns now is ~10 lines of SQL. | +| `shared_with_groups[] + is_public` instead of tri-state visibility enum | More compact but `visibility = 'private'` documents intent at the row level; a CHECK constraint can later enforce array/enum consistency. Two columns conveying one fact is fine when both are referenced often. | +| Add `shared_with_users[]` for direct user-to-user sharing | A "group of one" subsumes it without an extra column and GIN index. Phase 3 CLI can auto-create singleton groups if a user requests direct shares. | +| Bake per-domain or per-tag sharing defaults into Phase 2 schema | Sharing automation needs real usage data before committing to fuzzy (domain centroids) vs crisp (tags) vs context (codebase / MCP caller). Phase 4 designs a generic `sharing_rules` table that matches on any context dimension; deferring costs nothing because rules live in a new table, not new columns. | +| `codebase` stays in JSONB metadata | High-frequency query path (HDBSCAN scoping, codebase-wide searches, future `sharing_rules` match). B-tree on a real column beats GIN on a JSONB key for this access pattern. Cost is one nullable TEXT column. | + +--- + +## Consequences + +### Positive +- Phase 1 trait stops boxing futures on every call. Lifetimes and Send-ness + become inspectable instead of hidden inside an `async_trait` macro expansion. +- `connect` stays backend-agnostic; tests and CLI tools stand up either backend + without an `Embedder` in scope. +- Cognitive module imports never change paths -- the SQLite split is private + to `storage/sqlite/`, public re-exports through `storage/mod.rs` unchanged. +- Postgres backend lands already-modular; future SQL changes touch one of + seven small files, not one of eight thousand lines. +- Phase 2 master plan stays archival; ADR 0002 + sub-plans are the live source + of truth for execution. +- Multi-tenancy columns reserved now means Phase 3 auth is purely additive -- + no online migration over a populated, HNSW-indexed `knowledge_nodes` table. +- Context-aware ingest (D8) keeps the door open for repo / session / + MCP-caller-scoped sharing rules in Phase 4 without changing `knowledge_nodes`. + +### Negative +- The Phase 1 amendment expands a "finished" branch. It is a real cost: the + trait rewrite touches every cognitive module that holds a store handle. +- SQLite split is a pure-motion diff. Annoying to review even when safe. +- Three PRs (amendment, ADR+plans, implementation) instead of one or two. + Discipline tax in exchange for reviewability. +- Multi-tenancy reservation adds three never-queried tables and three + always-default columns to the SQLite schema. Real but small storage cost in + single-user mode (a single bootstrap row + empty tables + NULL/empty + defaults per memory). + +### Risks +- **Trait rewrite breaks a cognitive module's Send-ness expectation.** + Mitigation: `cargo test --workspace` runs after each call-site edit; + trait_variant-generated `MemoryStore` is the Send variant and matches the + current `Arc` usage everywhere except thread-local impls (none + exist today). +- **SQLite motion commit introduces a silent semantic change.** Mitigation: + each commit keeps `cargo test -p vestige-core` green; reviewer can bisect. +- **Sub-plan boundaries don't match how implementation wants to commit.** + Mitigation: sub-plans are advisory; the implementation PR clusters commits + however it ends up needing to. +- **Reserved columns get used in Phase 3 in a way that mismatches Phase 2 + defaults.** Mitigation: Phase 3 owns the auth filter; Phase 2 defaults + (`owner_user_id = local`, `visibility = 'private'`) are intentionally the + "no access for anyone but the owner" worst-case; widening at Phase 3 is + safe, narrowing would be the dangerous direction. +- **Memory: PR A amendment invalidates the locally-deployed Phase 1 binary's + ABI.** Not a real risk -- the trait change is purely source-level Rust; the + on-disk DB schema is unchanged. The rebuilt binary slots in over the + current one without DB migration. + +--- + +## Resolved Decisions + +| # | Question | Resolution | +|---|----------|------------| +| Q1 | Phase 1 trait shape | Rewrite with trait_variant::make. Amend Phase 1 PR. | +| Q2 | PgMemoryStore::connect signature | Mirror SqliteMemoryStore::new; no Embedder. register_model does the pgvector typmod stamp. | +| Q3 | Split sqlite.rs | Yes, as Phase 1 amendment. sqlite.rs -> sqlite/ directory; pure code motion. | +| Q4 | Postgres module layout | Directory from day one. | +| Q5 | Sub-plan granularity | Logical groups, ~9 docs for Phase 2 plus 2 for the Phase 1 amendment. | +| Q6 | ADR for SQLite split | No. Sub-plan `0001b-sqlite-split.md` is sufficient. | +| Q7 | Multi-tenancy schema | Reserve users / groups / group_memberships tables and owner_user_id / visibility / shared_with_groups columns on knowledge_nodes in Phase 2. Single-user defaults; Phase 3 fills in real values. | +| Q8 | Visibility encoding | Tri-state enum `'private' \| 'group' \| 'public'` plus `shared_with_groups[]`. No `shared_with_users[]`; no RLS in Phase 2. | +| Q9 | Sharing automation grain | Per-memory only in Phase 2. Phase 4 ships a generic `sharing_rules` table matching on codebase / tag / node_type / mcp_client_id. | +| Q10 | Context capture on ingest | `codebase` promoted to a first-class indexed column; `mcp_client_id` and `session_id` stay in metadata JSONB. | + +--- + +## Follow-ups + +- Phase 1 amendment sub-plans drafted: `0001a-trait-rewrite.md`, + `0001b-sqlite-split.md`, `0001c-async-trait-sunset.md`. Ready to execute on + `feat/storage-trait-phase1`. +- Phase 2 sub-plans drafted: `0002a-` through `0002i-` against the accepted + decisions above. Ready to execute on a new branch off PR A's tip. +- Decide branch placement for this ADR before it gets committed -- it cannot + live on `feat/storage-trait-phase1` (that branch is now PR A's code-only + amendment branch). Likely a new branch off PR A's tip for PR B (docs only). +- Validate local Postgres dev cluster before PR C work begins. Recipe at + `docs/plans/local-dev-postgres-setup.md` is correct but needs to be applied + on this machine (delandtj-home): cluster is not initdb'd, pgvector is not + installed. Containerized `pgvector/pgvector:pg16` is a viable alternative + if pgvector packaging is friction. See open discussion thread. + +### Phase 4 sketch: `sharing_rules` and the precedence chain + +Recorded here so the Phase 4 author does not have to rediscover the design. +Phase 2 does **not** implement any of this; it only ensures the schema and +ingest context capture make this possible without a `knowledge_nodes` migration. + +```sql +-- Phase 4 migration (not Phase 2) +CREATE TABLE sharing_rules ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + owner_user_id UUID NOT NULL REFERENCES users(id), + -- Match: any subset; all set fields must match conjunctively + match_codebase TEXT, + match_tag TEXT, + match_node_type TEXT, + match_api_key_id UUID REFERENCES api_keys(id), -- MCP caller identity + -- Policy + visibility TEXT NOT NULL, + shared_with_groups UUID[] NOT NULL DEFAULT '{}', + -- Conflict resolution + priority INTEGER NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); +``` + +Precedence on ingest, first match wins: + +1. Caller-explicit visibility in the MCP request +2. Active session override held by the MCP server (per-session, in-memory, + not persisted; matched by `session_id`) +3. Highest-priority `sharing_rules` row whose match fields all hold +4. User's `default_visibility` (typically `'private'`) + +Per-session overrides do not persist; storing ephemeral session IDs as DB +rows is waste. Per-codebase / per-MCP-caller rules do persist as +`sharing_rules` rows. From 697ade5b02decdfaf1165958f945f0f92b905497 Mon Sep 17 00:00:00 2001 From: Jan De Landtsheer Date: Wed, 27 May 2026 09:35:37 +0200 Subject: [PATCH 06/23] docs(plans): add Phase 1 amendment sub-plans 0001a/b/c Three sub-plans operationalising ADR 0002 D1 + D3 on the existing feat/storage-trait-phase1 branch (790c0c8, not yet pushed upstream): - 0001a-trait-rewrite.md -- rewrite MemoryStore with #[trait_variant::make(MemoryStore: Send)] generating a non-Send LocalMemoryStore companion. Production callers use Arc and are unaffected; only the trait declaration and SQLite impl block change. - 0001b-sqlite-split.md -- pure code motion. Split sqlite.rs (8713 lines) into a sqlite/ directory (mod, crud, search, scheduling, graph, domain, registry, portable_sync, trait_impl). Public re-exports unchanged; tests green commit-by-commit. Depends on 0001a so trait_impl.rs picks up the trait_variant attribute once. - 0001c-async-trait-sunset.md -- rewrite Embedder the same way, then remove async-trait = "0.1" from crates/vestige-core/Cargo.toml. End state: zero async_trait references in the workspace. Together these three lands as PR A. --- docs/plans/0001a-trait-rewrite.md | 689 ++++++++++++++++++++ docs/plans/0001b-sqlite-split.md | 732 +++++++++++++++++++++ docs/plans/0001c-async-trait-sunset.md | 847 +++++++++++++++++++++++++ 3 files changed, 2268 insertions(+) create mode 100644 docs/plans/0001a-trait-rewrite.md create mode 100644 docs/plans/0001b-sqlite-split.md create mode 100644 docs/plans/0001c-async-trait-sunset.md diff --git a/docs/plans/0001a-trait-rewrite.md b/docs/plans/0001a-trait-rewrite.md new file mode 100644 index 0000000..354e138 --- /dev/null +++ b/docs/plans/0001a-trait-rewrite.md @@ -0,0 +1,689 @@ +# Phase 1 Amendment Sub-Plan: async_trait -> trait_variant + +**Status**: Draft +**Depends on**: Phase 1 (already on `feat/storage-trait-phase1`, tip 790c0c8) +**Followed by**: `docs/plans/0001c-async-trait-sunset.md` (Embedder rewrite + async-trait crate removal) +**Related**: docs/adr/0002-phase-2-execution.md (decision D1), docs/plans/0001-phase-1-storage-trait-extraction.md + +--- + +## Context + +Phase 1 froze with the storage trait declared as +`#[async_trait::async_trait] pub trait MemoryStore: Send + Sync + 'static` +and a `pub use MemoryStore as LocalMemoryStore;` alias. `async_trait` boxes +every `async fn` in the trait into `Pin>`. That is one +heap allocation per call inside the hottest code path in Vestige (insert, +search, update_scheduling are all on this surface). It also collapses the +two intended trait shapes -- a Send-bound `MemoryStore` for tokio/axum and a +non-Send `LocalMemoryStore` for thread-local backends -- into a single trait +behind an alias, removing the type-system signal we will want for Phase 2's +Postgres backend. + +ADR 0002 decision D1 supersedes this. The amendment lands on the existing +`feat/storage-trait-phase1` branch before Phase 2 starts, before the PR is +opened upstream. The end state: + +- `LocalMemoryStore` is the source-of-truth trait, declared with native + async-fn-in-trait (stable on MSRV 1.91), no `Sync` bound on the trait + itself, and `Sync + 'static` on the trait object. +- `MemoryStore` is auto-generated by `#[trait_variant::make(MemoryStore: Send)]` + with `Send` bounds on every returned future, so `Arc` is + movable across `tokio::spawn`. +- `trait-variant` 0.1 is already present in `crates/vestige-core/Cargo.toml`. + The `async-trait` crate dependency stays in place through this sub-plan + (it is still in use by the embedder impl); removing it is the job of + `0001c-async-trait-sunset.md`. +- No production caller changes. Every production call site holds + `Arc` (the concrete `SqliteMemoryStore` alias), which the trait + rewrite does not touch. Only the trait declaration and impl blocks change. + +--- + +## Scope + +### In scope + +- Rewrite `MemoryStore` / `LocalMemoryStore` declaration in + `crates/vestige-core/src/storage/memory_store.rs` to use + `#[trait_variant::make(MemoryStore: Send)] pub trait LocalMemoryStore`. +- Remove the `pub use MemoryStore as LocalMemoryStore;` alias from the same + file. `LocalMemoryStore` becomes the real trait; `MemoryStore` is the + generated Send variant. +- Drop the `#[async_trait::async_trait]` attribute on the SQLite impl block + in `crates/vestige-core/src/storage/sqlite.rs` (line 6274). The impl block + switches from `impl MemoryStore for SqliteMemoryStore` (currently spelled + through the `LocalMemoryStore` alias) to `impl LocalMemoryStore for + SqliteMemoryStore`. `trait_variant` provides a blanket `impl MemoryStore for T` so `&dyn MemoryStore` and + `Arc` keep working unchanged. +- Update doc comments in `memory_store.rs` to drop + references to `#[async_trait::async_trait]` and instead describe the + `trait_variant` mechanism. +- Keep the existing Phase 1 test suite (`tests/phase_1/*.rs`) green. The + tests already use `Arc` and `Box`, which is + exactly the surface the rewrite is meant to preserve. + +### Out of scope -- moved to 0001c + +- Rewriting the `Embedder` / `LocalEmbedder` trait declaration -- handled by + `0001c-async-trait-sunset.md`. +- Dropping `#[async_trait::async_trait]` from + `crates/vestige-core/src/embedder/fastembed.rs`. +- Removing `async-trait = "0.1"` from `crates/vestige-core/Cargo.toml`. +- The hard `grep -rn 'async_trait' crates/` zero-match gate (async_trait is + still present in the embedder module after 0001a alone). + +### Out of scope + +- The SQLite file split (`sqlite.rs` -> `sqlite/` directory). That is the + sibling sub-plan `0001b-sqlite-split.md`. +- Any production-side refactor that switches `Arc` to + `Arc`. Production code keeps using the concrete alias. +- Adding `register_model` / `from_pool` / Postgres-specific variants of + `MemoryStoreError`. Those land with the Postgres backend in Phase 2. +- Removing the `pub type Storage = SqliteMemoryStore;` alias. + +--- + +## Prerequisites + +### Current state (verified) + +- `crates/vestige-core/Cargo.toml` already declares + `trait-variant = "0.1"` (line 117). `async-trait = "0.1"` (line 119) + remains in place for the duration of this sub-plan; `0001c` removes it. +- `crates/vestige-core/src/storage/memory_store.rs:194` declares the trait + with `#[async_trait::async_trait] pub trait MemoryStore: Send + Sync + + 'static`. +- `crates/vestige-core/src/storage/memory_store.rs:262` has + `pub use MemoryStore as LocalMemoryStore;`. +- `crates/vestige-core/src/storage/sqlite.rs:6274` declares + `#[async_trait::async_trait] impl + crate::storage::memory_store::LocalMemoryStore for SqliteMemoryStore`. +- Production call sites use `Arc` (the concrete + `SqliteMemoryStore` alias). Confirmed by grep: + `grep -rn "dyn MemoryStore\|dyn LocalMemoryStore" --include="*.rs"` + returns hits only in `tests/phase_1/*.rs`, in two comments inside + `memory_store.rs` and `sqlite.rs`, and in one test-only `&dyn MemoryStore` + cast inside `sqlite.rs::tests` (line 8669). +- Workspace-wide `async_trait` usages: only the trait declarations and + impl blocks in `memory_store.rs`, `sqlite.rs`, `embedder/mod.rs`, and + `embedder/fastembed.rs` (verified by + `grep -rn async_trait --include="*.rs"`). This sub-plan touches only the + first two; the embedder files are addressed by `0001c`. + +### Required crates + +| Crate | Version | Action | +|-------|---------|--------| +| `trait-variant` | `0.1` | Already declared. Verify present after edit. | +| `async-trait` | `0.1` | Unchanged for this sub-plan (still used by embedder impl). Removed by `0001c`. | +| `blake3`, `thiserror`, `chrono`, `uuid`, `serde`, `serde_json` | unchanged | unchanged | + +--- + +## Files Touched + +Grouped by category. Every change is listed; nothing else gets touched. + +### Trait declarations (vestige-core) + +| File | Lines (approx) | Change | +|------|----------------|--------| +| `crates/vestige-core/src/storage/memory_store.rs` | 183-262 | Replace `#[async_trait::async_trait]` block with `#[trait_variant::make(MemoryStore: Send)] pub trait LocalMemoryStore`. Drop the `pub use MemoryStore as LocalMemoryStore;` alias. Update doc comments. | + +### Impl blocks (vestige-core) + +| File | Lines (approx) | Change | +|------|----------------|--------| +| `crates/vestige-core/src/storage/sqlite.rs` | 6274 (impl block header only) | Delete the `#[async_trait::async_trait]` attribute. Keep the `impl crate::storage::memory_store::LocalMemoryStore for SqliteMemoryStore { ... }` body verbatim. | + +### Cargo dependency cleanup + +None in this sub-plan. The `async-trait` crate stays declared in +`crates/vestige-core/Cargo.toml` because the embedder impl still uses it. +`0001c-async-trait-sunset.md` removes the dependency after the embedder +side is rewritten. + +### Cognitive module call sites + +No changes. The 29 cognitive modules under `crates/vestige-core/src/neuroscience/` +and `crates/vestige-core/src/advanced/` already operate on concrete +`SqliteMemoryStore` (via the `Storage` alias) or on plain data types +(`KnowledgeNode`, `Vec`, `ConnectionRecord`). Grep verified zero +production references to `dyn MemoryStore` or `dyn LocalMemoryStore`. + +### MCP call sites + +No changes. All ~30 `vestige-mcp/src/**.rs` files holding `Arc` +keep working because: +- `Storage` is still `pub type Storage = SqliteMemoryStore;` (unchanged). +- They call inherent methods on the concrete type, never via a trait object. +- `SqliteMemoryStore` implements `LocalMemoryStore`; `trait_variant` auto- + generates a blanket `impl MemoryStore for T`, + so the concrete type also satisfies `MemoryStore` for any future caller + that wants the trait-object form. + +### Test files (vestige-core integration tests) + +| File | Lines | Change | +|------|-------|--------| +| `tests/phase_1/trait_round_trip.rs` | 7-18, 134 | No change. Already uses `Arc` and `use vestige_core::storage::MemoryStore`. trait_variant emits a `MemoryStore` trait at the same path, so the imports resolve. | +| `tests/phase_1/send_bound_variant.rs` | 10-12, 36, 57 | No change. Already asserts the trait_variant Send invariant; the rewrite is what makes the doc comment on lines 3-4 actually true. | +| `tests/phase_1/cognitive_module_isolation.rs` | 11, 37, 76, 102, 115 | No change. | +| `tests/phase_1/embedding_model_registry.rs` | 10 | No change. | +| `tests/phase_1/domain_column_migration.rs` | 98 | No change. | +| `crates/vestige-core/src/storage/sqlite.rs::tests` | 8666-8675 | No change. The existing test casts `&s` to `&dyn MemoryStore` and calls trait methods through that vtable; trait_variant preserves this exact dyn-compatible surface. | + +### Documentation + +| File | Change | +|------|--------| +| `crates/vestige-core/src/storage/memory_store.rs` | Rewrite the trait-level doc comment (lines 185-193) to describe trait_variant rather than async_trait. | +| `CLAUDE.md` | No change. The repo-level architecture notes do not name the trait attribute. | + +--- + +## Trait Declaration Rewrite + +### Before (current state on `feat/storage-trait-phase1`) + +`crates/vestige-core/src/storage/memory_store.rs:183-262`: + +```rust +// ---------------------------------------------------------------------------- +// TRAIT +// ---------------------------------------------------------------------------- + +/// The single storage abstraction. +/// +/// `#[async_trait::async_trait]` makes every `async fn` return a +/// `Pin>`, which is required for `Arc` +/// to be movable across `tokio::spawn` boundaries. +/// +/// `LocalMemoryStore` is a type alias kept for source compatibility with code +/// that refers to the non-send variant. In Phase 1 both names refer to the same +/// (dyn-compatible, Send-safe) trait. +#[async_trait::async_trait] +pub trait MemoryStore: Send + Sync + 'static { + // --- Lifecycle --- + async fn init(&self) -> MemoryStoreResult<()>; + async fn health_check(&self) -> MemoryStoreResult; + + // ... 25 more async fn ... + + async fn vacuum(&self) -> MemoryStoreResult<()>; +} + +/// Type alias kept for source compatibility. Both names refer to the same +/// `async_trait`-annotated trait that is dyn-compatible and `Send + Sync`. +pub use MemoryStore as LocalMemoryStore; +``` + +### After + +`crates/vestige-core/src/storage/memory_store.rs:183-262`: + +```rust +// ---------------------------------------------------------------------------- +// TRAIT +// ---------------------------------------------------------------------------- + +/// The single storage abstraction. +/// +/// `LocalMemoryStore` is the source-of-truth trait. The +/// `#[trait_variant::make(MemoryStore: Send)]` attribute auto-generates a +/// `MemoryStore` trait whose returned futures are `Send`, so +/// `Arc` is movable across `tokio::spawn` boundaries while +/// `Arc` remains usable on single-threaded executors +/// and thread-local backends. +/// +/// Every method is native async-fn-in-trait (stable on MSRV 1.91); no +/// per-call heap allocation, no boxed futures. +#[trait_variant::make(MemoryStore: Send)] +pub trait LocalMemoryStore: Sync + 'static { + // --- Lifecycle --- + async fn init(&self) -> MemoryStoreResult<()>; + async fn health_check(&self) -> MemoryStoreResult; + + // --- Embedding model registry --- + async fn registered_model(&self) -> MemoryStoreResult>; + async fn register_model(&self, sig: &ModelSignature) -> MemoryStoreResult<()>; + + // --- CRUD --- + async fn insert(&self, record: &MemoryRecord) -> MemoryStoreResult; + async fn get(&self, id: Uuid) -> MemoryStoreResult>; + async fn update(&self, record: &MemoryRecord) -> MemoryStoreResult<()>; + async fn delete(&self, id: Uuid) -> MemoryStoreResult<()>; + + // --- Search --- + async fn search(&self, query: &SearchQuery) -> MemoryStoreResult>; + async fn fts_search(&self, text: &str, limit: usize) -> MemoryStoreResult>; + async fn vector_search( + &self, + embedding: &[f32], + limit: usize, + ) -> MemoryStoreResult>; + + // --- FSRS Scheduling --- + async fn get_scheduling( + &self, + memory_id: Uuid, + ) -> MemoryStoreResult>; + async fn update_scheduling(&self, state: &SchedulingState) -> MemoryStoreResult<()>; + async fn get_due_memories( + &self, + before: DateTime, + limit: usize, + ) -> MemoryStoreResult>; + + // --- Graph (spreading activation) --- + async fn add_edge(&self, edge: &MemoryEdge) -> MemoryStoreResult<()>; + async fn get_edges( + &self, + node_id: Uuid, + edge_type: Option<&str>, + ) -> MemoryStoreResult>; + async fn remove_edge(&self, source: Uuid, target: Uuid) -> MemoryStoreResult<()>; + async fn get_neighbors( + &self, + node_id: Uuid, + depth: usize, + ) -> MemoryStoreResult>; + + // --- Domains --- + async fn list_domains(&self) -> MemoryStoreResult>; + async fn get_domain(&self, id: &str) -> MemoryStoreResult>; + async fn upsert_domain(&self, domain: &Domain) -> MemoryStoreResult<()>; + async fn delete_domain(&self, id: &str) -> MemoryStoreResult<()>; + async fn classify(&self, embedding: &[f32]) -> MemoryStoreResult>; + + // --- Bulk / Maintenance --- + async fn count(&self) -> MemoryStoreResult; + async fn get_stats(&self) -> MemoryStoreResult; + async fn vacuum(&self) -> MemoryStoreResult<()>; +} +``` + +Notes: + +- The `pub use MemoryStore as LocalMemoryStore;` line on the current + `memory_store.rs:262` is **deleted** entirely. `MemoryStore` is now the + generated trait that `trait_variant::make` emits at the same module path; + `LocalMemoryStore` is the source-of-truth declaration. Both names export + from `storage/mod.rs` already (see lines 10-14 of that file). +- `Sync + 'static` on `LocalMemoryStore` (and no `Send` bound on the trait + itself) is correct: `Send` on the trait is what `trait_variant::make` + inserts when it emits the `MemoryStore` variant. The current trait carries + `Send + Sync + 'static`; the rewrite drops the `Send` bound from the + local variant. `Arc` is `Sync` but not `Send`; + `Arc` (the generated variant) is `Send + Sync`. +- `trait_variant` 0.1 does **not** require any attribute on the impl block. + The attribute lives only on the trait declaration. See the next section. + +The Embedder trait rewrite uses the identical `trait_variant::make` pattern +and is fully specified in `0001c-async-trait-sunset.md`. + +--- + +## Impl Block Migration + +`trait_variant` 0.1 attaches the attribute only to the trait declaration. +The impl side is plain `impl LocalMemoryStore for SqliteMemoryStore`; no +attribute on the impl, no `#[trait_variant::make(MemoryStore: Send)]` on the +impl block. The crate auto-generates the blanket +`impl MemoryStore for T`, so any concrete type +that implements `LocalMemoryStore` automatically also implements +`MemoryStore` provided it is `Send`. + +`SqliteMemoryStore` already is `Send + Sync` (it holds `Mutex` +fields whose `Mutex` is `std::sync::Mutex`, which is `Send + Sync` when its +guarded type is `Send`; `rusqlite::Connection` is `Send`). No new bound is +needed. + +### Before + +`crates/vestige-core/src/storage/sqlite.rs:6274`: + +```rust +#[async_trait::async_trait] +impl crate::storage::memory_store::LocalMemoryStore for SqliteMemoryStore { + async fn init(&self) -> crate::storage::memory_store::MemoryStoreResult<()> { + // Migrations run in `new`; this is a no-op for the SQLite backend. + Ok(()) + } + + // ... ~2400 lines of method bodies, unchanged ... +} +``` + +### After + +`crates/vestige-core/src/storage/sqlite.rs:6274`: + +```rust +impl crate::storage::memory_store::LocalMemoryStore for SqliteMemoryStore { + async fn init(&self) -> crate::storage::memory_store::MemoryStoreResult<()> { + // Migrations run in `new`; this is a no-op for the SQLite backend. + Ok(()) + } + + // ... ~2400 lines of method bodies, unchanged ... +} +``` + +Diff is exactly one removed line (the `#[async_trait::async_trait]` attribute). +Every method body, every `async fn` signature, every `use` statement inside +the impl block stays verbatim. No `Box::pin(async move { ... })`, no manual +`Pin>`, no `'async_trait` lifetime markers; native +async-fn-in-trait does this directly. + +The Embedder impl block rewrite follows the identical "remove one +`#[async_trait::async_trait]` attribute" pattern and is fully specified in +`0001c-async-trait-sunset.md`. + +### Why the impl block does not need an attribute + +`trait_variant::make` generates two things from the source trait: + +1. The source trait itself (`LocalMemoryStore`), with native async fns. +2. A second trait (`MemoryStore`) whose method signatures return + `impl Future + Send` instead of `impl Future`, + plus a blanket impl wiring concrete types through. + +Both are emitted at the macro-call site. `SqliteMemoryStore` only writes one +impl block (against `LocalMemoryStore`); the macro-generated blanket +guarantees `SqliteMemoryStore: MemoryStore` for free. The current `&dyn +MemoryStore` casts (sqlite.rs:8669; tests under tests/phase_1/) keep +type-checking unchanged. + +--- + +## Call Site Audit + +Verified via: + +```bash +grep -rn "dyn MemoryStore\|dyn LocalMemoryStore" --include="*.rs" \ + /home/delandtj/prppl/vestige-phase2/ +grep -rn "Arc\|Arc" --include="*.rs" \ + /home/delandtj/prppl/vestige-phase2/ +grep -rn "use.*MemoryStore;\|use.*LocalMemoryStore;" --include="*.rs" \ + /home/delandtj/prppl/vestige-phase2/ +``` + +### Files that reference the trait object form (`dyn MemoryStore` / `dyn LocalMemoryStore`) + +All test-only or doc-comment-only: + +| File | Line | Use | Required change | +|------|------|-----|-----------------| +| `tests/phase_1/trait_round_trip.rs` | 7-18 | `Arc` in `make_store()` and test bodies | None. `MemoryStore` is the generated Send variant; signature stays. | +| `tests/phase_1/trait_round_trip.rs` | 134 | `Arc` upcast inside a test body | None. | +| `tests/phase_1/send_bound_variant.rs` | 10-97 | `Arc` moved across `tokio::spawn` | None. This test becomes meaningfully correct only after the rewrite (currently it relies on async_trait boxing; after the rewrite it relies on trait_variant's Send variant -- same observable outcome). | +| `tests/phase_1/cognitive_module_isolation.rs` | 11, 33-115 | `Arc` passed into cognitive module-style closures | None. | +| `tests/phase_1/embedding_model_registry.rs` | 10 | `Arc` in `make_store()` | None. | +| `tests/phase_1/domain_column_migration.rs` | 98 | `Arc` cast inside a migration assertion | None. | +| `crates/vestige-core/src/storage/sqlite.rs` | 8666-8675 | `let dyn_s: &dyn MemoryStore = &s;` inside `mod tests` | None. The cast is testing that the dyn-vtable still resolves the trait methods correctly; after the rewrite it resolves through the `MemoryStore` trait that `trait_variant::make` emits at the same path. | +| `crates/vestige-core/src/storage/memory_store.rs` | 188 (doc) | Doc comment mentioning `Arc` | Replaced as part of the doc rewrite (see Trait Declaration section). | + +### Files that hold the concrete type (`Arc` / `Arc`) + +35 files, 116 hits. Every one of them keeps working unchanged because the +concrete `SqliteMemoryStore` type stays exactly as it is. Listed here for +completeness so a reviewer can confirm none of them needs an edit: + +``` +crates/vestige-core/src/storage/mod.rs (alias declaration) +crates/vestige-core/src/storage/sqlite.rs (impl block) +crates/vestige-mcp/src/server.rs (Arc in McpServer) +crates/vestige-mcp/src/cognitive.rs (hydrate(&Storage)) +crates/vestige-mcp/src/autopilot.rs +crates/vestige-mcp/src/protocol/http.rs +crates/vestige-mcp/src/dashboard/mod.rs +crates/vestige-mcp/src/dashboard/state.rs +crates/vestige-mcp/src/dashboard/handlers.rs +crates/vestige-mcp/src/resources/codebase.rs +crates/vestige-mcp/src/resources/memory.rs +crates/vestige-mcp/src/tools/changelog.rs +crates/vestige-mcp/src/tools/codebase_unified.rs +crates/vestige-mcp/src/tools/context.rs +crates/vestige-mcp/src/tools/contradictions.rs +crates/vestige-mcp/src/tools/cross_reference.rs +crates/vestige-mcp/src/tools/dedup.rs +crates/vestige-mcp/src/tools/dream.rs +crates/vestige-mcp/src/tools/explore.rs +crates/vestige-mcp/src/tools/feedback.rs +crates/vestige-mcp/src/tools/graph.rs +crates/vestige-mcp/src/tools/health.rs +crates/vestige-mcp/src/tools/importance.rs +crates/vestige-mcp/src/tools/intention_unified.rs +crates/vestige-mcp/src/tools/maintenance.rs +crates/vestige-mcp/src/tools/memory_states.rs +crates/vestige-mcp/src/tools/memory_unified.rs +crates/vestige-mcp/src/tools/predict.rs +crates/vestige-mcp/src/tools/restore.rs +crates/vestige-mcp/src/tools/review.rs +crates/vestige-mcp/src/tools/search_unified.rs +crates/vestige-mcp/src/tools/session_context.rs +crates/vestige-mcp/src/tools/smart_ingest.rs +crates/vestige-mcp/src/tools/suppress.rs +crates/vestige-mcp/src/tools/tagging.rs +crates/vestige-mcp/src/tools/timeline.rs +``` + +Each holds `Arc` and dispatches to inherent methods on +`SqliteMemoryStore`. None of them goes through a trait vtable. Required +change for every one of them: **none**. + +### Files that `use ...MemoryStore` from production code + +``` +grep -rn "use.*MemoryStore;\|use.*LocalMemoryStore;" --include="*.rs" \ + | grep -v "memory_store.rs\|sqlite.rs\|tests/phase_1" +``` + +returns nothing. Production code does not import the trait by name. + +### Conclusion + +The rewrite is a strictly local change to two source files +(`storage/memory_store.rs` and `storage/sqlite.rs`). Zero production call +sites need edits. The integration tests that consume `Arc` +keep their current form; the rewrite is what gives that signature its +no-box semantics on the storage side. The `Box` surface is +addressed by `0001c-async-trait-sunset.md`. + +--- + +## Commit Sequence + +Two commits, each green on `cargo test -p vestige-core --no-default-features` +and `cargo test -p vestige-core --features embeddings,vector-search`. + +### Commit 1: rewrite MemoryStore / LocalMemoryStore trait declaration + +- Touches: `crates/vestige-core/src/storage/memory_store.rs` only. +- Action: replace lines 183-262 per the "Trait Declaration Rewrite" section + above. Delete the `pub use MemoryStore as LocalMemoryStore;` line. +- Green after: `cargo check -p vestige-core` (the impl block in `sqlite.rs` + still has `#[async_trait::async_trait]` on it, but it still resolves + through the `LocalMemoryStore` trait which is now native-async; the + `async_trait` macro is harmless when applied to a trait that the impl + block targets by path, because the macro rewrites the impl's async fns + into boxed-future fns whose signatures still match the native-async + declarations after trait_variant lowering). If `cargo check` complains + here, fold commit 2 into commit 1. + + **Mitigation if check fails between commits 1 and 2:** combine the two + into a single commit. The split is offered for review convenience; the + build must be green after every commit lands. + +### Commit 2: drop `#[async_trait::async_trait]` from SqliteMemoryStore impl + +- Touches: `crates/vestige-core/src/storage/sqlite.rs` only. +- Action: delete line 6274 (`#[async_trait::async_trait]`). +- Green after: `cargo test -p vestige-core --features embeddings,vector-search`, + including all `trait_*` tests inside `sqlite.rs::tests` (lines 8643-8712) + and the trait-object cast on line 8669. + +### Combined alternative + +If the per-step split feels artificial, commits 1 and 2 can collapse into +a single commit covering both the trait rewrite and the impl-attribute +drop for `MemoryStore`. That is acceptable; the two-commit form is +preferred only because it lets a reviewer bisect trait-rewrite failures +separately from impl-rewrite failures. + +The Embedder / fastembed commits and the `async-trait` Cargo dependency +removal live in `0001c-async-trait-sunset.md`. + +--- + +## Verification + +Every command runs from the repo root unless noted otherwise. + +```bash +# 1. Vestige-core, default features (embeddings + vector-search). +cargo test -p vestige-core --features embeddings,vector-search + +# 2. Vestige-core, minimal features (no embeddings, no vector-search). +cargo test -p vestige-core --no-default-features + +# 3. Workspace build, release mode (catches any feature-gated regression +# in the vestige-mcp tools tree). +cargo build --workspace --release + +# 4. Whole-workspace test (vestige-mcp 406 tests + vestige-core 352 tests +# per the CLAUDE.md baseline). +cargo test --workspace + +# 5. Phase 1 integration tests (these are the trait-shape contract). +cargo test --test trait_round_trip --features embeddings,vector-search +cargo test --test send_bound_variant --features embeddings,vector-search +cargo test --test cognitive_module_isolation --features embeddings,vector-search +cargo test --test embedding_model_registry --features embeddings,vector-search +cargo test --test domain_column_migration --features embeddings,vector-search + +# 6. Clippy gate, deny warnings (matches Phase 1 PR policy of zero warnings). +cargo clippy --workspace --all-targets --features embeddings,vector-search -- -D warnings + +# 7. Storage-side dependency hygiene check (must return zero hits). +# Scoped to the storage module only -- the embedder module still uses +# async_trait until 0001c lands. +grep -rn "async_trait\|async-trait" crates/vestige-core/src/storage/ + +# 8. Confirm trait_variant attribute is in place on the storage trait +# (must return exactly one hit in memory_store.rs). +grep -rn "trait_variant::make" crates/vestige-core/src/storage/ +``` + +Expected outcomes: + +- Command 1: 352 tests pass (matches baseline). +- Command 2: smaller test count, all pass. +- Command 3: workspace compiles in release mode. +- Command 4: 758 total tests pass (matches CLAUDE.md baseline). +- Command 5: each phase_1 integration test binary runs green. The + `send_bound_variant::arc_dyn_memory_store_moves_across_tokio_tasks` test + is the canary; if `MemoryStore` lost its Send-bound future variant, this + fails to compile with "future cannot be sent between threads safely". +- Command 6: zero clippy warnings. The rewrite must not introduce a new + `clippy::needless_lifetimes` or `clippy::async_yields_async`. +- Command 7: empty output. async_trait is gone from the storage module. + The embedder module still contains async_trait; that is removed by + `0001c-async-trait-sunset.md`. +- Command 8: one hit, in `memory_store.rs`. + +--- + +## Acceptance Criteria + +A reviewer should be able to check every box: + +- [ ] `crates/vestige-core/src/storage/memory_store.rs` declares the trait + with `#[trait_variant::make(MemoryStore: Send)] pub trait + LocalMemoryStore: Sync + 'static`, no `async_trait` attribute, no + `Send` bound on `LocalMemoryStore` itself. +- [ ] `crates/vestige-core/src/storage/memory_store.rs` no longer contains + `pub use MemoryStore as LocalMemoryStore;`. +- [ ] `crates/vestige-core/src/storage/sqlite.rs:6274` is plain + `impl crate::storage::memory_store::LocalMemoryStore for + SqliteMemoryStore` -- no attribute on the impl block. +- [ ] `grep -rn "async_trait\|async-trait" crates/vestige-core/src/storage/` + returns zero hits. +- [ ] `grep -rn "trait_variant::make" crates/vestige-core/src/storage/` + returns exactly one hit (the storage trait in `memory_store.rs`). +- [ ] All 758 workspace tests pass (`cargo test --workspace`). +- [ ] Phase 1 integration tests pass with the trait-object surface + (`Arc`) intact. +- [ ] `cargo clippy --workspace --all-targets --features + embeddings,vector-search -- -D warnings` is clean. +- [ ] No production source file under `crates/vestige-mcp/` or + `crates/vestige-core/src/{neuroscience,advanced,consolidation,codebase, + memory,embeddings,embedder}/` was modified by this sub-plan. +- [ ] `Arc` still type-checks at every existing call site (verified + by the workspace test pass). +- [ ] Doc comments on the storage trait declaration describe + `trait_variant`, not `async_trait`. + +--- + +## Risks and Mitigations + +- **`trait_variant` 0.1 macro emits unexpected diagnostics on MSRV 1.91.** + Mitigation: the master Phase 1 plan already prescribed this exact pattern + (`#[trait_variant::make(MemoryStore: Send)] pub trait LocalMemoryStore: + Sync + 'static`, see plan `0001-...` line 274-275); the crate has been in + `vestige-core/Cargo.toml` since Phase 1 landed. If a diagnostic appears, + pin to the exact known-good version with `trait-variant = "=0.1.2"` and + open an upstream issue. +- **Native async-fn-in-trait makes the trait no longer dyn-compatible.** + Mitigation: `trait_variant::make` is specifically the workaround for this + -- it emits both the source trait (for static dispatch) and a Send-bound + variant whose returned futures use `Pin>` only at + the dyn boundary. `Arc` keeps working because the + generated `MemoryStore` trait is dyn-compatible by construction. Verified + by the existing `send_bound_variant::*` tests, which intentionally move + `Arc` across `tokio::spawn` from inside a + `multi_thread` runtime. +- **A cognitive module silently relied on the boxed-future return type.** + Mitigation: grep verified no cognitive module imports `MemoryStore` / + `LocalMemoryStore` or holds an `Arc` form; all of them use the + concrete `Storage` alias. There is no Send-ness expectation downstream to + break. +- **Future bodies inside the SQLite impl capture non-Send locals.** + Mitigation: every method body in `sqlite.rs:6274..` runs synchronous + rusqlite calls inside the same `async fn` frame; no `.await` points + exist inside the bodies that we ship today. The `Send` bound on the + generated `MemoryStore` variant is therefore satisfied automatically. + If a future change adds `.await` inside an impl method, the new + trait_variant surface will surface that as a compile error at the call + site, which is the correct outcome. +- **`async-trait` crate is left declared after this sub-plan.** + This is intentional: the embedder impl still depends on it. The + `0001c-async-trait-sunset.md` sub-plan removes the crate after the + embedder side is rewritten. Grep on the whole workspace returns only + the storage and embedder files; no downstream crate pulls `async-trait`. + +--- + +## Out-of-Band Notes + +- This sub-plan amends `feat/storage-trait-phase1` (tip 790c0c8). The + branch has not been opened upstream yet, so amending in place is safe; + no force-push to a public PR. +- The companion sub-plan `0001b-sqlite-split.md` lands after this one on + the same branch. The trait-rewrite landing first is intentional: the + SQLite split moves the impl block into `storage/sqlite/trait_impl.rs`, + and it is cleaner to move a small attribute-free impl than a + macro-decorated one. +- The companion sub-plan `0001c-async-trait-sunset.md` lands after this + one (order with `0001b` is independent) and finishes the + async_trait -> trait_variant transition for the Embedder trait, then + removes the `async-trait` crate dependency. +- After the Phase 1 amendment sub-plans (`0001a`, `0001b`, `0001c`) land, + the branch is reviewed and merged before Phase 2 sub-plans (`0002a-` + through `0002i-`) begin implementation. diff --git a/docs/plans/0001b-sqlite-split.md b/docs/plans/0001b-sqlite-split.md new file mode 100644 index 0000000..ce2590d --- /dev/null +++ b/docs/plans/0001b-sqlite-split.md @@ -0,0 +1,732 @@ +# Sub-Plan 0001b: Split sqlite.rs into a sqlite/ directory + +**Status**: Draft +**Branch**: `feat/storage-trait-phase1` (Phase 1 amendment, PR A) +**Depends on**: `0001a-trait-rewrite.md` (must land first; it carries the +`trait_variant`-generated trait declaration that `trait_impl.rs` matches) +**Related**: `docs/adr/0002-phase-2-execution.md` (D3, D6) + +--- + +## Context + +`crates/vestige-core/src/storage/sqlite.rs` is the single SQLite backend file +that Phase 1 inherited from pre-trait Vestige and then appended the +`LocalMemoryStore` trait impl block to. The file is 8713 lines as of +commit 790c0c8 on `feat/storage-trait-phase1`. ADR 0002 D3 decides to split +it into a `sqlite/` directory before Phase 2 lands `postgres/` as a peer. +Reasoning, in one paragraph: + +The Postgres backend is going in as a directory of seven small files +(`postgres/{mod,pool,migrations,registry,search,migrate_cli,reembed}.rs`). +If SQLite stays as one 8K-line file alongside that, the repo says "backends +look like one big file or seven small ones, pick a side", which forces +every future maintainer to re-litigate the layout. Splitting now -- as +**pure code motion**, no public-API change, no behavioural change, no +migration -- lets both backends look the same, keeps each surface mappable +in a single editor tab, and shrinks the diffs Phase 2 has to review. +This sub-plan is sized as one focused implementation session. + +The split is **private** to `storage/sqlite/`. Cognitive modules continue +to `use crate::storage::SqliteMemoryStore`; the existing re-exports in +`crates/vestige-core/src/storage/mod.rs` keep working without touching +any caller. Tests stay green commit-by-commit. + +This sub-plan depends on `0001a-trait-rewrite.md` landing first because +`sqlite/trait_impl.rs` is the file that picks up the new trait_variant +attribute. Doing the split first would force a second rewrite of +`trait_impl.rs` when the trait rewrite arrives. Order matters; this is +the cheap-to-respect ordering. + +--- + +## Target Layout + +Final directory after this sub-plan: + +``` +crates/vestige-core/src/storage/sqlite/ + mod.rs -- module root: SqliteMemoryStore struct, new(), + reader/writer locks, error types, shared helpers, + portable-sync-related types, record types + crud.rs -- ingest/smart_ingest/get/update/delete/purge/search-by-id + search.rs -- fts, semantic, hybrid, time-based queries + scheduling.rs -- FSRS state, decay, consolidation, review, promote/demote, + suppression, gc, retention, waking tags + graph.rs -- memory_connections (edges), subgraph, neighbors + domain.rs -- domains/domain_scores column readers, classify stub + (Phase 4 will expand this file) + registry.rs -- embedding_model table, enforce_model, register_model body + portable_sync.rs -- portable export/import/sync + merge helpers + trait_impl.rs -- impl LocalMemoryStore for SqliteMemoryStore +``` + +`storage/mod.rs` is unchanged in spirit: it still does `mod sqlite;` and +`pub use sqlite::{...};` -- the only difference is that `sqlite` is now a +directory module instead of a leaf file. The re-export list does not +change. + +--- + +## Current File Map (line numbers from commit 790c0c8) + +The current `sqlite.rs` is structurally: + +| Region | Lines | Contents | +|--------|-------|----------| +| Header | 1-43 | Imports, feature-gated imports | +| Error types | 45-89 | `StorageError`, `Result`, `SmartIngestResult`, `MergeWrite` | +| Portable sync types | 97-211 | `PortableSyncBackend` trait, `FilePortableSyncBackend` struct, `PortableSyncReport`, `PurgeReport` | +| Constants | 233-273 | `PORTABLE_TABLES`, `PORTABLE_USER_DATA_TABLES`, `PortableMergeState`, env constants | +| Struct decl | 287-301 | `SqliteMemoryStore` struct fields | +| Impl block 1 | 303-3740 | Constructor + bulk of native API | +| Record structs | 3747-3866 | `IntentionRecord`, `InsightRecord`, `ConnectionRecord`, `MemoryStateRecord`, `StateTransitionRecord`, `ConsolidationHistoryRecord`, `DreamHistoryRecord`, `Default for InsightRecord` | +| Impl block 2 | 3868-6133 | Intentions / Insights / Connections / States / History / Backup / Portable / GC / Subgraph | +| Impl block 3 | 6139-6272 | Trait-helper methods (`node_to_record`, `read_domain_columns`, `enforce_model`) | +| Trait impl | 6274-7110 | `impl LocalMemoryStore for SqliteMemoryStore` | +| Tests | 7112-8713 | `#[cfg(test)] mod tests`: native API tests + trait round-trip tests | + +--- + +## Mapping Table + +Every public method, every private helper, every struct, every test module +in the current file -- with the destination file in the new layout. Line +ranges cite the current `sqlite.rs` (commit 790c0c8 on +`feat/storage-trait-phase1`, viewed through the +`/home/delandtj/prppl/vestige-phase2` worktree). + +### Header and shared types (-> `sqlite/mod.rs`) + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| Module-level `use` imports | 1-43 | `sqlite/mod.rs` | Trimmed per-file in destination; what does not fit in `mod.rs` moves with its consumers | +| `StorageError` enum + `Result` alias | 49-71 | `sqlite/mod.rs` | Re-exported through `pub use` chain; called from every sub-module | +| `SmartIngestResult` struct | 73-89 | `sqlite/mod.rs` | Returned by `crud::smart_ingest`; defined here because other code depends on the type | +| `MergeWrite` enum | 91-95 | `sqlite/portable_sync.rs` | Only used by merge helpers | +| `PortableSyncBackend` trait | 97-109 | `sqlite/portable_sync.rs` | Public trait; re-exported through `mod.rs` | +| `FilePortableSyncBackend` struct + `impl` | 111-194 | `sqlite/portable_sync.rs` | | +| `PortableSyncReport` struct | 196-211 | `sqlite/portable_sync.rs` | | +| `PurgeReport` struct | 213-231 | `sqlite/crud.rs` | Returned by `purge_node` | +| `PORTABLE_TABLES` constant | 237-254 | `sqlite/portable_sync.rs` | | +| `PORTABLE_USER_DATA_TABLES` constant | 256-272 | `sqlite/portable_sync.rs` | | +| `PortableMergeState` struct | 274-277 | `sqlite/portable_sync.rs` | | +| `DATA_DIR_ENV` constant | 279 | `sqlite/mod.rs` | Read by constructor | +| `DATABASE_FILE` constant | 280 | `sqlite/mod.rs` | Read by constructor | +| `SqliteMemoryStore` struct decl | 282-301 | `sqlite/mod.rs` | All fields stay public-to-crate within the directory | + +### Constructor and config (-> `sqlite/mod.rs`) + +These are foundational; they live in `mod.rs` because every sub-module +calls them or operates on the struct they build. + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `fn data_dir_from_env` | 304-313 | `sqlite/mod.rs` | private helper | +| `fn expand_tilde` | 314-332 | `sqlite/mod.rs` | private helper | +| `fn prepare_data_dir` | 333-346 | `sqlite/mod.rs` | private helper | +| `pub fn db_path_for_data_dir` | 347-355 | `sqlite/mod.rs` | | +| `pub fn default_db_path` | 356-368 | `sqlite/mod.rs` | | +| `fn configure_connection` | 369-396 | `sqlite/mod.rs` | | +| `pub fn new` | 397-457 | `sqlite/mod.rs` | The constructor | +| `pub fn db_path` | 458-462 | `sqlite/mod.rs` | | +| `pub fn data_dir` | 463-467 | `sqlite/mod.rs` | | +| `pub fn sidecar_dir` | 468-473 | `sqlite/mod.rs` | | +| `fn load_embeddings_into_index` | 474-552 | `sqlite/mod.rs` | Called by `new`; touches vector index | + +### CRUD: ingest, get, update, delete, purge (-> `sqlite/crud.rs`) + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `pub fn ingest` | 553-643 | `sqlite/crud.rs` | | +| `pub fn smart_ingest` | 644-864 | `sqlite/crud.rs` | Calls vector search via `self.semantic_search`; cross-module call resolved by impl block being on the same struct | +| `pub fn get_node_embedding` (vector-search) | 865-887 | `sqlite/crud.rs` | embedding read for one node | +| `pub fn get_all_embeddings` (vector-search) | 888-914 | `sqlite/crud.rs` | | +| `pub fn get_node_embedding` (no vector-search stub) | 915-919 | `sqlite/crud.rs` | feature-gated alternative | +| `pub fn update_node_content` | 920-951 | `sqlite/crud.rs` | | +| `fn generate_embedding_for_node` | 952-999 | `sqlite/crud.rs` | private helper; only called by ingest and update_node_content | +| `pub fn get_node` | 1000-1011 | `sqlite/crud.rs` | | +| `fn parse_timestamp` | 1012-1027 | `sqlite/mod.rs` | **Shared helper**: row_to_node uses it, intention/insight rows also parse timestamps. Bump to `pub(super) fn` | +| `fn row_to_node` | 1028-1119 | `sqlite/mod.rs` | **Shared helper**: crud reads single nodes; search.rs builds node lists from rows; scheduling.rs returns nodes for review queue. Bump to `pub(super) fn`. Static method (no `&self`) so a free function in `mod.rs` is fine | +| `pub fn delete_node` | 1842-1869 | `sqlite/crud.rs` | | +| `pub fn purge_node` | 1870-1987 | `sqlite/crud.rs` | | +| `fn node_exists` | 1988-1996 | `sqlite/crud.rs` | static helper, called only by purge | +| `fn record_sync_tombstone` | 1997-2014 | `sqlite/crud.rs` | static helper, called by delete and purge | +| `pub fn get_all_nodes` | 2268-2291 | `sqlite/crud.rs` | bulk read | +| `pub fn get_nodes_by_type_and_tag` | 2292-2342 | `sqlite/crud.rs` | bulk read | + +### Search: fts, semantic, hybrid, temporal (-> `sqlite/search.rs`) + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `pub fn recall` | 1120-1147 | `sqlite/search.rs` | top-level recall path | +| `fn keyword_search` | 1148-1180 | `sqlite/search.rs` | private | +| `pub fn search` | 2015-2043 | `sqlite/search.rs` | | +| `pub fn search_terms` | 2044-2075 | `sqlite/search.rs` | | +| `pub fn concrete_search_filtered` | 2076-2172 | `sqlite/search.rs` | | +| `fn upsert_concrete_result` | 2173-2197 | `sqlite/search.rs` | static helper | +| `fn normalize_literal_query` | 2198-2210 | `sqlite/search.rs` | static helper | +| `fn escape_like` | 2211-2224 | `sqlite/search.rs` | static helper | +| `fn literal_match_score` | 2225-2248 | `sqlite/search.rs` | static helper | +| `fn node_matches_type_filters` | 2249-2267 | `sqlite/search.rs` | static helper | +| `pub fn is_embedding_ready` (both feature variants) | 2343-2354 | `sqlite/search.rs` | both versions move together | +| `pub fn init_embeddings` (both feature variants) | 2355-2367 | `sqlite/search.rs` | both versions move together | +| `fn get_query_embedding` | 2368-2400 | `sqlite/search.rs` | private; uses `query_cache` field | +| `pub fn semantic_search` | 2401-2434 | `sqlite/search.rs` | | +| `pub fn hybrid_search` (feature on) | 2435-2452 | `sqlite/search.rs` | | +| `pub fn hybrid_search_filtered` (feature on) | 2453-2581 | `sqlite/search.rs` | | +| `pub fn hybrid_search` (feature off) | 2582-2593 | `sqlite/search.rs` | feature-gated stub | +| `pub fn hybrid_search_filtered` (feature off) | 2594-2635 | `sqlite/search.rs` | feature-gated stub | +| `fn keyword_search_with_scores` | 2636-2726 | `sqlite/search.rs` | | +| `fn semantic_search_raw` | 2727-2765 | `sqlite/search.rs` | | +| `pub fn generate_embeddings` | 2766-2819 | `sqlite/search.rs` | populates embeddings post hoc | +| `fn embedding_regeneration_candidates` | 2820-2891 | `sqlite/search.rs` | called by generate_embeddings | +| `pub fn query_at_time` | 2892-2933 | `sqlite/search.rs` | temporal query | +| `pub fn query_time_range` | 2934-3005 | `sqlite/search.rs` | temporal query | +| `fn embedding_model_matches_active` (associated fn) | 5652-5671 | `sqlite/search.rs` | static helper for hybrid_search; promoted to `pub(super)` (test references it) | +| `fn embedding_model_supports_matryoshka` | 5672-5677 | `sqlite/search.rs` | static helper | +| `fn embedding_vector_for_active_model` | 5678-5697 | `sqlite/search.rs` | static helper | +| `fn active_embedding_model_like_pattern` | 5698-5713 | `sqlite/search.rs` | static helper | + +### Scheduling: FSRS, decay, consolidation, review, promote/demote, suppression, gc, retention (-> `sqlite/scheduling.rs`) + +This is the busiest destination file. The grouping rule is: anything that +touches FSRS scheduling fields (`stability`, `difficulty`, `retrievability`, +`reps`, `lapses`, `retention_strength`, `retrieval_strength`) or the +review/decay/consolidation/gc lifecycle lives here. + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `pub fn mark_reviewed` | 1181-1275 | `sqlite/scheduling.rs` | FSRS state mutation | +| `pub fn strengthen_on_access` | 1276-1344 | `sqlite/scheduling.rs` | | +| `pub fn strengthen_batch_on_access` | 1345-1357 | `sqlite/scheduling.rs` | | +| `pub fn mark_memory_useful` | 1358-1377 | `sqlite/scheduling.rs` | | +| `fn log_access` | 1378-1393 | `sqlite/scheduling.rs` | private | +| `pub fn promote_memory` | 1394-1425 | `sqlite/scheduling.rs` | | +| `pub fn demote_memory` | 1426-1472 | `sqlite/scheduling.rs` | | +| `pub fn suppress_memory` | 1473-1504 | `sqlite/scheduling.rs` | active forgetting | +| `pub fn reverse_suppression` | 1505-1552 | `sqlite/scheduling.rs` | | +| `pub fn count_suppressed` | 1553-1567 | `sqlite/scheduling.rs` | | +| `pub fn get_recently_suppressed` | 1568-1594 | `sqlite/scheduling.rs` | | +| `pub fn apply_rac1_cascade` | 1595-1641 | `sqlite/scheduling.rs` | active forgetting cascade | +| `pub fn run_rac1_cascade_sweep` | 1642-1657 | `sqlite/scheduling.rs` | | +| `pub fn get_review_queue` | 1658-1681 | `sqlite/scheduling.rs` | | +| `pub fn preview_review` | 1682-1712 | `sqlite/scheduling.rs` | | +| `pub fn get_stats` | 1713-1841 | `sqlite/scheduling.rs` | reports retention/lapses/review counts; lives here for symmetry with the FSRS reporters next door | +| `pub fn apply_decay` | 3006-3095 | `sqlite/scheduling.rs` | core decay loop | +| `fn get_fsrs_w20` | 3096-3119 | `sqlite/scheduling.rs` | | +| `pub fn run_consolidation` | 3120-3407 | `sqlite/scheduling.rs` | | +| `fn auto_dedup_consolidation` | 3408-3538 | `sqlite/scheduling.rs` | called by run_consolidation | +| `fn compute_act_r_activations` | 3539-3605 | `sqlite/scheduling.rs` | called by run_consolidation | +| `fn prune_access_log` | 3606-3620 | `sqlite/scheduling.rs` | called by run_consolidation | +| `fn optimize_w20_if_ready` | 3621-3720 | `sqlite/scheduling.rs` | called by run_consolidation | +| `fn generate_missing_embeddings` | 3721-3740 | `sqlite/scheduling.rs` | called by run_consolidation | +| `pub fn get_state_transitions` | 5714-5748 | `sqlite/scheduling.rs` | audit trail tied to scheduling state | +| `pub fn get_avg_retention` | 5780-5792 | `sqlite/scheduling.rs` | | +| `pub fn get_retention_distribution` | 5794-5825 | `sqlite/scheduling.rs` | | +| `pub fn get_retention_trend` | 5826-5858 | `sqlite/scheduling.rs` | | +| `pub fn save_retention_snapshot` | 5859-5878 | `sqlite/scheduling.rs` | | +| `pub fn count_memories_below_retention` | 5879-5892 | `sqlite/scheduling.rs` | | +| `pub fn gc_below_retention` | 5893-5936 | `sqlite/scheduling.rs` | | +| `pub fn auto_promote_frequent_access` | 5937-5985 | `sqlite/scheduling.rs` | | +| `pub fn set_waking_tag` | 5986-5998 | `sqlite/scheduling.rs` | waking SWR tagging | +| `pub fn clear_waking_tags` | 5999-6011 | `sqlite/scheduling.rs` | | +| `pub fn get_waking_tagged_memories` | 6012-6028 | `sqlite/scheduling.rs` | | +| `pub fn get_recent_state_transitions` | 6105-6132 | `sqlite/scheduling.rs` | | + +### Graph: edges (memory_connections), neighbors, subgraph (-> `sqlite/graph.rs`) + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `pub fn save_connection` | 4180-4202 | `sqlite/graph.rs` | | +| `pub fn get_connections_for_memory` | 4203-4220 | `sqlite/graph.rs` | | +| `pub fn get_all_connections` | 4221-4236 | `sqlite/graph.rs` | | +| `pub fn strengthen_connection` | 4237-4259 | `sqlite/graph.rs` | | +| `pub fn apply_connection_decay` | 4260-4272 | `sqlite/graph.rs` | | +| `pub fn prune_weak_connections` | 4273-4284 | `sqlite/graph.rs` | | +| `fn row_to_connection` | 4285-4305 | `sqlite/graph.rs` | private | +| `pub fn get_most_connected_memory` | 6029-6046 | `sqlite/graph.rs` | | +| `pub fn get_memory_subgraph` | 6048-6103 | `sqlite/graph.rs` | calls `get_connections_for_memory`, `get_node`, `get_all_connections` -- all resolvable through `self` | + +### Domain (-> `sqlite/domain.rs`) + +Phase 1 keeps domain logic to JSON-column reads + classify stub. Phase 4 +expands this file. Keeping the file in the split so Phase 4 has an +obvious place to add to. + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `fn read_domain_columns` | 6167-6196 | `sqlite/domain.rs` | private helper used by trait `get`. Bump to `pub(super)` | + +The trait methods `list_domains` / `get_domain` / `upsert_domain` / +`delete_domain` / `classify` live in `sqlite/trait_impl.rs`; they +delegate to thin helpers that, in Phase 1, are essentially noops or +JSON reads. Phase 4 will move the substance of those methods into +`sqlite/domain.rs` as real functions. + +### Registry: embedding_model table (-> `sqlite/registry.rs`) + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `fn enforce_model` | 6203-6272 | `sqlite/registry.rs` | private helper used by trait `insert` and `update`. Bump to `pub(super)` | + +The trait methods `registered_model` and `register_model` themselves +live in `sqlite/trait_impl.rs`. Phase 2's `postgres/registry.rs` will +mirror this layout. + +### Intentions, Insights, Memory States, Consolidation History, Dream History, Backup (-> `sqlite/mod.rs`) + +These were tacked onto `SqliteMemoryStore` over time as the cognitive +modules needed somewhere to persist their state. They are not part of the +trait surface, they are not naturally grouped with crud/search/scheduling, +and they are each fairly small and self-contained. They live in `mod.rs` +under labelled sections (one big impl block can carry them) rather than +inventing extra files like `intentions.rs` and `insights.rs`. Postgres +will mirror this once Phase 5 picks up the work; for now they have no +peer. + +Rationale: every one of these methods writes to a single table, the +bodies are short, and grouping them next to the constructor preserves +"open `mod.rs` to see the whole struct" as the navigation default. + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `IntentionRecord` struct | 3747-3766 | `sqlite/mod.rs` | re-exported through `storage/mod.rs` | +| `InsightRecord` struct + `Default` | 3767-3797 | `sqlite/mod.rs` | re-exported | +| `ConnectionRecord` struct | 3799-3809 | `sqlite/mod.rs` | re-exported; consumed by `graph.rs` | +| `MemoryStateRecord` struct | 3811-3821 | `sqlite/mod.rs` | | +| `StateTransitionRecord` struct | 3823-3833 | `sqlite/mod.rs` | re-exported | +| `ConsolidationHistoryRecord` struct | 3835-3846 | `sqlite/mod.rs` | | +| `DreamHistoryRecord` struct | 3848-3866 | `sqlite/mod.rs` | re-exported | +| `pub fn save_intention` etc. (intention block) | 3874-4058 | `sqlite/mod.rs` | one impl block, in-section labelled | +| `fn row_to_intention` | 4023-4058 | `sqlite/mod.rs` | private | +| insights block (`save_insight`, `get_insights`, etc.) | 4065-4174 | `sqlite/mod.rs` | | +| `fn row_to_insight` | 4153-4173 | `sqlite/mod.rs` | private | +| memory-state block | 4306-4459 | `sqlite/mod.rs` | | +| `fn row_to_memory_state` | 4431-4459 | `sqlite/mod.rs` | private | +| consolidation-history block | 4465-4540 | `sqlite/mod.rs` | | +| dream-history block | 4546-4638 | `sqlite/mod.rs` | | +| `pub fn count_memories_since` | 4639-4651 | `sqlite/mod.rs` | | +| `fn scan_last_backup_timestamp` | 4652-4682 | `sqlite/mod.rs` | | +| `pub fn last_backup_timestamp` | 4683-4688 | `sqlite/mod.rs` | | +| `pub fn get_last_backup_timestamp` (associated) | 4689-4696 | `sqlite/mod.rs` | | +| `pub fn backup_to` | 5749-5774 | `sqlite/mod.rs` | sqlite VACUUM INTO; called by backup tool | + +### Portable export/import/sync (-> `sqlite/portable_sync.rs`) + +This is the second-largest destination after `scheduling.rs` and the most +self-contained. + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `pub fn export_portable_archive` | 4699-4755 | `sqlite/portable_sync.rs` | | +| `pub fn export_portable_archive_to_path` | 4756-4806 | `sqlite/portable_sync.rs` | | +| `pub fn import_portable_archive` | 4807-4978 | `sqlite/portable_sync.rs` | | +| `pub fn import_portable_archive_from_path` | 4979-4996 | `sqlite/portable_sync.rs` | | +| `pub fn sync_portable_archive` (generic over backend) | 4997-5025 | `sqlite/portable_sync.rs` | | +| `pub fn sync_portable_archive_file` | 5026-5030 | `sqlite/portable_sync.rs` | | +| `fn merge_portable_table` | 5031-5073 | `sqlite/portable_sync.rs` | | +| `fn merge_knowledge_nodes` | 5074-5126 | `sqlite/portable_sync.rs` | | +| `fn merge_sync_tombstones` | 5127-5204 | `sqlite/portable_sync.rs` | | +| `fn merge_deletion_tombstones` | 5205-5245 | `sqlite/portable_sync.rs` | | +| `fn merge_keyed_table` | 5246-5281 | `sqlite/portable_sync.rs` | | +| `fn row_references_locally_newer_node` | 5282-5302 | `sqlite/portable_sync.rs` | | +| `fn merge_append_only_table` | 5303-5338 | `sqlite/portable_sync.rs` | | +| `fn parent_rows_exist` | 5339-5370 | `sqlite/portable_sync.rs` | | +| `fn insert_or_replace_row` | 5371-5386 | `sqlite/portable_sync.rs` | | +| `fn merge_key_columns` | 5387-5398 | `sqlite/portable_sync.rs` | | +| `fn upsert_row_with_columns` | 5399-5446 | `sqlite/portable_sync.rs` | | +| `fn insert_row_with_columns` | 5447-5469 | `sqlite/portable_sync.rs` | | +| `fn merge_row_exists` | 5470-5487 | `sqlite/portable_sync.rs` | | +| `fn row_exists_by_values` | 5488-5507 | `sqlite/portable_sync.rs` | | +| `fn row_values_for_columns` | 5508-5528 | `sqlite/portable_sync.rs` | | +| `fn portable_value` | 5529-5540 | `sqlite/portable_sync.rs` | | +| `fn portable_text` | 5541-5551 | `sqlite/portable_sync.rs` | | +| `fn portable_timestamp` | 5552-5559 | `sqlite/portable_sync.rs` | | +| `fn parse_rfc3339_opt` | 5560-5565 | `sqlite/portable_sync.rs` | | +| `fn tombstone_timestamp` | 5566-5580 | `sqlite/portable_sync.rs` | | +| `fn current_schema_version` | 5581-5589 | `sqlite/portable_sync.rs` | static helper | +| `fn ensure_portable_import_target_empty` | 5590-5604 | `sqlite/portable_sync.rs` | static helper | +| `fn table_exists` | 5605-5613 | `sqlite/portable_sync.rs` | static helper | +| `fn table_row_count` | 5614-5618 | `sqlite/portable_sync.rs` | static helper | +| `fn table_columns` | 5619-5630 | `sqlite/portable_sync.rs` | static helper | +| `fn portable_value_from_ref` | 5631-5646 | `sqlite/portable_sync.rs` | static helper | +| `fn quote_ident` | 5647-5651 | `sqlite/portable_sync.rs` | static helper | + +### Trait helpers and trait impl (-> `sqlite/trait_impl.rs`) + +| Item | Lines | Destination | Notes | +|------|-------|-------------|-------| +| `fn node_to_record` | 6142-6164 | `sqlite/trait_impl.rs` | associated fn used only by trait body; co-locate | +| `impl LocalMemoryStore for SqliteMemoryStore` block | 6274-7110 | `sqlite/trait_impl.rs` | full trait impl; attribute changes from `#[async_trait::async_trait]` to whatever 0001a settles on (`#[trait_variant::make(...)]` is on the trait declaration; the impl block carries no attribute under trait_variant) | + +### Tests + +The current `#[cfg(test)] mod tests` block at lines 7112-8713 contains +**two** distinct test families: + +1. **Native API tests** (7120-8198): unit tests against the legacy + `pub fn` surface (`test_ingest_and_get`, `test_search`, `test_review`, + `test_delete`, `test_dream_history_save_and_get_last`, + `test_portable_archive_exact_round_trip`, `test_keyword_search_*`, + `test_concrete_search_*`, `test_purge_*`, etc.). +2. **Trait round-trip tests** (8200-8712, after the + `// ===== Phase 1: LocalMemoryStore trait round-trip tests =====` + banner): `trait_init_is_idempotent`, `trait_register_model_*`, + `trait_insert_*`, `trait_get_*`, `trait_update_*`, `trait_delete_*`, + `trait_fts_search_*`, `trait_hybrid_search_*`, + `trait_scheduling_*`, `trait_add_edge_*`, `trait_get_edges_*`, + `trait_remove_edge_*`, `trait_get_neighbors_*`, `trait_list_domains_*`, + `trait_upsert_*`, `trait_classify_*`, `trait_count_*`, + `trait_get_stats_*`, `trait_vacuum_*`, + `trait_insert_refuses_dimension_mismatch`. + +See the Test Relocation section below for the resolution. + +--- + +## Visibility Changes + +The split moves items into sibling files inside one module. Helpers that +were `fn ...` (i.e. crate-private but file-private under the current +layout, since the file *is* the module) need their visibility lifted +just enough that sibling files can call them. The principle is: smallest +bump that makes the call site compile. + +`pub(super)` is sufficient for everything below; nothing needs +`pub(crate)`. The trait `LocalMemoryStore` exposure does not change -- +sub-modules call `self.method(...)` on `SqliteMemoryStore`, which +resolves through the impl blocks defined in their own files; visibility +is automatic at impl-block scope. + +Items that need a visibility bump (currently private fn, become +`pub(super) fn`): + +- `parse_timestamp` (1012): called by `row_to_node` and by intention / + insight row mappers. +- `row_to_node` (1028): called by `crud.rs`, `search.rs`, + `scheduling.rs`. Static associated fn. +- `read_domain_columns` (6167): called by `trait_impl.rs`. +- `enforce_model` (6203): called by `trait_impl.rs`. +- `embedding_model_matches_active` (5652): currently called by + `hybrid_search_filtered`; tests also reference it. Has to remain + `pub(super) fn` and be `pub` only if the existing test names reach it + through a re-export. (See Test Relocation.) +- `embedding_model_supports_matryoshka` (5672): private; only callers in + `search.rs` after the move; stays `fn` (no bump needed). +- `embedding_vector_for_active_model` (5678): same as the matches + function -- a test references it. Bump to `pub(super)`. +- `active_embedding_model_like_pattern` (5698): private; only used by + search; stays `fn`. +- `generate_embedding_for_node` (952): currently called by `ingest` and + `update_node_content`. Both move to `crud.rs`; stays `fn`. +- `get_query_embedding` (2368): only used inside `search.rs`; stays `fn`. +- `keyword_search_with_scores` (2636): only used inside `search.rs`; + stays `fn`. +- `semantic_search_raw` (2727): only used inside `search.rs`; stays `fn`. +- `embedding_regeneration_candidates` (2820): used by + `generate_embeddings`; both move to `search.rs`; stays `fn`. The + existing test (line 7167) references it through `storage.method()`, + which will continue to work because the test file can move with it. +- `log_access` (1378): private to `scheduling.rs`; stays `fn`. +- All the `auto_dedup_consolidation` / `compute_act_r_activations` / + `prune_access_log` / `optimize_w20_if_ready` / + `generate_missing_embeddings` helpers (3408-3740): private to + `scheduling.rs`; stays `fn`. +- `row_to_intention` / `row_to_insight` / `row_to_memory_state` / + `row_to_connection`: all stay private in their destination file (only + one caller each). +- All `merge_*` / `portable_*` / `parse_rfc3339_opt` / `quote_ident`: + private to `portable_sync.rs`; stays `fn`. +- `node_exists` (1988): private to `crud.rs`; stays `fn`. +- `record_sync_tombstone` (1997): private to `crud.rs`; stays `fn`. +- `get_fsrs_w20` (3096): private to `scheduling.rs`; stays `fn`. + +Items already `pub fn` (or `pub(crate) fn`) stay as they are -- no +visibility regression. + +Field visibility on `SqliteMemoryStore` itself: currently all fields are +private. The sub-modules access them via `self.field`. Because impl +blocks for `SqliteMemoryStore` are written in sibling files of the same +module, `self.field` reaches private fields without a visibility bump. +**No field visibility changes are required.** Confirm this during the +first motion commit; if Rust disagrees, mark the relevant fields +`pub(super)` and document in the commit message. + +--- + +## Public Re-exports + +`crates/vestige-core/src/storage/mod.rs` currently exports: + +```rust +mod memory_store; +mod migrations; +mod portable; +mod sqlite; + +pub use memory_store::{...}; +pub use migrations::MIGRATIONS; +pub use portable::{...}; +pub use sqlite::{ + ConnectionRecord, ConsolidationHistoryRecord, DreamHistoryRecord, FilePortableSyncBackend, + InsightRecord, IntentionRecord, PortableSyncBackend, PortableSyncReport, Result, + SmartIngestResult, SqliteMemoryStore, StateTransitionRecord, StorageError, +}; + +pub type Storage = SqliteMemoryStore; +``` + +After the split, `mod sqlite;` resolves to the new directory module +(`storage/sqlite/mod.rs`). The `pub use sqlite::{...}` block resolves +against the items re-exported by `storage/sqlite/mod.rs`. + +`storage/sqlite/mod.rs` therefore needs the same names visible at its +top level. Add at the end of `mod.rs`: + +```rust +mod crud; +mod search; +mod scheduling; +mod graph; +mod domain; +mod registry; +mod portable_sync; +mod trait_impl; + +pub use portable_sync::{FilePortableSyncBackend, PortableSyncBackend, PortableSyncReport}; +// SqliteMemoryStore, StorageError, Result, SmartIngestResult, IntentionRecord, +// InsightRecord, ConnectionRecord, StateTransitionRecord, +// ConsolidationHistoryRecord, DreamHistoryRecord are defined in mod.rs itself, +// so they are already in scope and do not need a re-export. +``` + +The `crates/vestige-core/src/storage/mod.rs` file does not change. The +`pub type Storage = SqliteMemoryStore;` alias keeps working. + +If `cargo build` complains that `storage/mod.rs` cannot resolve a name +in its `pub use sqlite::{...}` block, the fix is to add the missing name +to `sqlite/mod.rs`'s re-export tail; no change to `storage/mod.rs`. + +--- + +## Test Relocation + +Two test families, two destinations. + +**Native API tests** (current lines 7120-8198) cover the legacy `pub fn` +surface. They live close to their subject: + +- Tests that touch the constructor, common helpers, and shared setup + (`create_test_storage`, `create_test_storage_at`, + `test_storage_creation`, `test_get_last_backup_timestamp_no_panic`) + move to `sqlite/mod.rs` in a `#[cfg(test)] mod tests` block. +- `test_ingest_and_get`, `test_delete`, + `test_purge_scrubs_insight_json_orphans_children_and_writes_tombstone` + go to `sqlite/crud.rs` as a `#[cfg(test)] mod tests` block. +- `test_search`, `test_keyword_search_with_include_types`, + `test_keyword_search_with_exclude_types`, + `test_include_types_takes_precedence_over_exclude`, + `test_type_filter_with_no_matches_returns_empty`, + `test_hybrid_search_backward_compat`, + `test_concrete_search_literal_identifier_lands_first`, + `test_embedding_model_family_matching`, + `test_embedding_regeneration_candidates_include_entire_mismatched_corpus` + go to `sqlite/search.rs`. +- `test_review` goes to `sqlite/scheduling.rs`. +- `test_dream_history_save_and_get_last`, `test_dream_history_empty`, + `test_count_memories_since` go to `sqlite/mod.rs` (history tables live + there). +- All `test_portable_*` go to `sqlite/portable_sync.rs`. +- `test_file_portable_sync_round_trips_between_devices` goes to + `sqlite/portable_sync.rs`. + +**Trait round-trip tests** (current lines 8200-8712) test the +`LocalMemoryStore` trait impl. Two viable layouts: + +A. Co-locate with the impl in `sqlite/trait_impl.rs` (one big + `#[cfg(test)] mod trait_tests`). +B. Keep them as a single `tests.rs` file in the sqlite directory. + +**Decision: A.** Co-locate. The trait round-trip tests are explicitly +testing the `impl LocalMemoryStore for SqliteMemoryStore` block; +co-location means a reader who edits the trait impl sees its tests in +the same file. Option B would mean two places to look every time a +trait method changes shape. For an 8K-line collapse the tradeoff +favours co-location. + +Concretely: `sqlite/trait_impl.rs` ends with a +`#[cfg(test)] mod trait_tests { ... }` block that contains all 30+ +`trait_*` tests, plus the shared `make_record`, `rt`, and small helpers +defined inside the current test mod for trait tests (lines 8208-8226). + +--- + +## Commit Sequence + +Each commit moves one logical group. After each commit: + +``` +cargo build -p vestige-core +cargo test -p vestige-core +cargo clippy -p vestige-core -- -D warnings +``` + +must pass. Order is chosen so that each move is small, the next move +does not depend on the previous having grown surprising visibility, and +the largest / riskiest move (the trait impl, with the new +trait_variant attribute) lands last. + +| # | Commit | What moves | Tests touched | +|---|--------|-----------|----------------| +| 1 | `refactor(sqlite): scaffold sqlite/ directory` | Convert `sqlite.rs` -> `sqlite/mod.rs` verbatim (rename + create empty sibling files `crud.rs`, `search.rs`, `scheduling.rs`, `graph.rs`, `domain.rs`, `registry.rs`, `portable_sync.rs`, `trait_impl.rs` each with `use super::*;`). At this point `mod.rs` declares the new modules but they are empty. | None move. Build proves the rename works. | +| 2 | `refactor(sqlite): split out portable sync` | Move all `merge_*`, `portable_*`, `export_*`, `import_*`, `sync_*` items + `MergeWrite`, `PortableSyncBackend`, `FilePortableSyncBackend`, `PortableSyncReport`, `PortableMergeState`, `PORTABLE_TABLES`, `PORTABLE_USER_DATA_TABLES`, helper statics into `sqlite/portable_sync.rs`. Add `pub use portable_sync::{...}` in `mod.rs` for the public types. | `test_portable_*` and `test_file_portable_sync_round_trips_between_devices` move too. | +| 3 | `refactor(sqlite): split out graph / connections` | Move `save_connection`, `get_connections_for_memory`, `get_all_connections`, `strengthen_connection`, `apply_connection_decay`, `prune_weak_connections`, `row_to_connection`, `get_most_connected_memory`, `get_memory_subgraph` to `sqlite/graph.rs`. | None move (no native graph tests; trait edge tests still in trait_tests). | +| 4 | `refactor(sqlite): split out scheduling / fsrs / consolidation` | Move all items listed in the Scheduling row to `sqlite/scheduling.rs`. | `test_review` moves. | +| 5 | `refactor(sqlite): split out search / fts / semantic / hybrid` | Move all items listed in the Search row to `sqlite/search.rs`. Add `pub(super)` to the four `embedding_model_*` helpers that tests reference. | `test_search`, `test_keyword_search_*`, `test_include_types_*`, `test_type_filter_*`, `test_hybrid_search_*`, `test_concrete_search_*`, `test_embedding_model_family_matching`, `test_embedding_regeneration_candidates_include_entire_mismatched_corpus` move. | +| 6 | `refactor(sqlite): split out crud / ingest / get / update / delete / purge` | Move `ingest`, `smart_ingest`, `get_node`, `update_node_content`, `delete_node`, `purge_node`, `get_all_nodes`, `get_nodes_by_type_and_tag`, `node_exists`, `record_sync_tombstone`, `generate_embedding_for_node`, `get_node_embedding`, `get_all_embeddings`, `PurgeReport` to `sqlite/crud.rs`. Bump `row_to_node` and `parse_timestamp` to `pub(super) fn` in `mod.rs`. | `test_ingest_and_get`, `test_delete`, `test_purge_scrubs_insight_json_orphans_children_and_writes_tombstone` move. | +| 7 | `refactor(sqlite): split out registry helper` | Move `enforce_model` to `sqlite/registry.rs`, bumped to `pub(super)`. | None move. | +| 8 | `refactor(sqlite): split out domain helper` | Move `read_domain_columns` to `sqlite/domain.rs`, bumped to `pub(super)`. | None move. | +| 9 | `refactor(sqlite): split out trait impl + tests` | Move `node_to_record` and the full `impl LocalMemoryStore for SqliteMemoryStore` block to `sqlite/trait_impl.rs`. Move the entire trait round-trip test module (lines 8200-8712, including `make_record` and `rt` helpers) to a `#[cfg(test)] mod trait_tests` block at the bottom of `trait_impl.rs`. This is the commit where the trait_variant attribute (from sub-plan 0001a) is observed: the impl block on `SqliteMemoryStore` uses whatever syntax the rewritten trait expects (no `#[async_trait::async_trait]`). | All `trait_*` tests move. | + +Commit 1 is the only commit that creates new files; the rest move +existing code into them. Reviewers can bisect through this list to +find any silent-semantic change. + +--- + +## Verification + +Run after every commit. All three must pass before pushing: + +``` +cargo build -p vestige-core +cargo test -p vestige-core +cargo clippy -p vestige-core -- -D warnings +``` + +The Phase 1 amendment branch must also build with the no-default-features +configuration that the release binary uses for the alternative feature +set: + +``` +cargo build -p vestige-core --no-default-features +cargo test -p vestige-core --no-default-features +``` + +Some of the methods being moved (`get_node_embedding`, `is_embedding_ready`, +`init_embeddings`, the feature-on/feature-off `hybrid_search` pair) have +two definitions guarded by feature flags. The split must preserve both +copies in the same destination file with their existing `#[cfg(...)]` +attributes; the no-default-features build confirms. + +After the last commit, run the workspace-wide check that Phase 1 promised: + +``` +cargo build --workspace +cargo test --workspace +``` + +This catches downstream consumers (`vestige-mcp`, `vestige`, +`vestige-restore`) that might depend on a specific module path (they +should not -- they import from `crate::storage::SqliteMemoryStore` and +the re-exports in `storage/mod.rs` -- but the workspace build is the +authoritative confirmation). + +--- + +## Acceptance Criteria + +1. `crates/vestige-core/src/storage/sqlite.rs` no longer exists. In its + place is `crates/vestige-core/src/storage/sqlite/` with the eight + files listed in the Target Layout section, each below 2000 lines. +2. `crates/vestige-core/src/storage/mod.rs` is unchanged (or + functionally unchanged -- the `pub use sqlite::{...}` block contains + the same identifiers in the same order). +3. Every cognitive module and binary in the workspace + (`vestige-core`, `vestige-mcp`, `vestige`, `vestige-restore`) + compiles with no source edits other than the ones in + `crates/vestige-core/src/storage/sqlite/`. +4. `cargo build -p vestige-core`, + `cargo test -p vestige-core`, + `cargo clippy -p vestige-core -- -D warnings`, + `cargo build -p vestige-core --no-default-features`, and + `cargo test -p vestige-core --no-default-features` all pass at the + end of every commit in the sequence (bisectability). +5. `cargo test --workspace` matches the Phase 1 baseline test count + (758 tests, of which 352 are in `vestige-core`). No new tests are + added by this sub-plan; no existing test is renamed or deleted. +6. The on-disk SQLite schema is unchanged. A live database created on + the pre-split build opens cleanly on the post-split build and round + trips a memory. +7. `git log --follow` works for at least one method in each destination + file (i.e. `git mv` was used where the line range constitutes most + of the file content of the destination, otherwise a `git log -p` + on the new file shows the history before the rename through the + block-move detection that recent `git log` versions support). +8. No public symbol disappears from `crate::storage::*`. A reviewer can + verify with: + ``` + cargo doc -p vestige-core --no-deps + ``` + before and after the split, and `diff` the generated + `target/doc/vestige_core/storage/index.html` lists. + +--- + +## Non-Goals (explicit) + +- No public API change. The trait surface (`LocalMemoryStore`, + `MemoryStore`), the legacy `pub fn` surface on `SqliteMemoryStore`, + the re-exports through `storage/mod.rs`, and the `pub type Storage = + SqliteMemoryStore;` alias are all preserved. +- No behavioural change. No SQL is rewritten, no FSRS parameter is + retuned, no embedding model is touched, no migration is added. +- No new tests. Tests move with their subject; no new tests are + written. +- No clippy fix-ups that pre-date this sub-plan. If `cargo clippy + -- -D warnings` was passing before the split, it must continue to + pass; if it was not passing, the failures stay where they are and + are addressed in a separate commit (out of scope here). +- No removal of the `pub type Storage = SqliteMemoryStore;` BC alias. + That happens at the end of Phase 4 per ADR 0001. +- No reorganisation of `storage/memory_store.rs`, + `storage/migrations.rs`, or `storage/portable.rs`. Those files are + out of scope; the split is private to `storage/sqlite/`. + +--- + +## Risks and Mitigations + +| Risk | Mitigation | +|------|------------| +| Silent semantic change introduced by a motion commit | Per-commit `cargo test -p vestige-core` keeps the bisect window to a single commit. Reviewer bisects with `cargo test -p vestige-core` as the witness. | +| Sibling-file `self.field` accesses fail because Rust enforces module visibility on tuple-struct or named fields | Confirmed: associated impl blocks in sibling files of the same `mod sqlite` reach private fields. If the compiler disagrees, bump the affected fields to `pub(super)` in `mod.rs` and note the bump in the commit message. | +| Test-only helpers (`create_test_storage`, `make_record`, `rt`) get duplicated across test modules | Lift them once into a `#[cfg(test)] mod test_support { ... }` sub-module in `sqlite/mod.rs` and re-export with `pub(super) use`. Do this in commit 1 (scaffold), not later. | +| `#[cfg(all(feature = "embeddings", feature = "vector-search"))]` items end up in `mod.rs` where they pollute the shared layer | Audit during commit 5 (search split); items behind both feature flags belong in `search.rs`. The `query_cache` field stays in `mod.rs` because the struct definition is there; the field declaration is feature-gated and that gate moves with the struct as-is. | +| `git log --follow` blame chains break on the moved methods | Use `git mv sqlite.rs sqlite/mod.rs` in commit 1 so commit 1 looks like a rename (`git log --follow` keeps working). Subsequent commits are content moves inside the module; modern `git log --follow -M -C` heuristics still trace the lines. Reviewers who need pristine blame should bisect to before commit 1. | +| Sub-plan 0001a (trait rewrite) has not landed when this work starts | Block: do not start commits 1-9 until 0001a is on the same branch (`feat/storage-trait-phase1`) and tests pass. `trait_impl.rs` lands the new attribute in commit 9; if 0001a is not in, commit 9 fails. | + +--- + +## Self-Contained Brief (for /goal) + +A fresh Claude Code session can execute this sub-plan by: + +1. Reading this file end to end. +2. Reading `crates/vestige-core/src/storage/sqlite.rs` (the file to be + split) in full, using line ranges from the Mapping Table to confirm + the current shape matches the brief. +3. Reading `crates/vestige-core/src/storage/mod.rs` (the re-export + surface that must continue to work). +4. Reading `crates/vestige-core/src/storage/memory_store.rs` (the + trait surface that `trait_impl.rs` implements). +5. Confirming sub-plan 0001a has landed on the current branch by + checking that `memory_store.rs` no longer carries + `#[async_trait::async_trait]` on the trait declaration. +6. Working through the Commit Sequence in order, running the + Verification commands after each commit. + +The session does not need to read ADR 0002 or the master Phase 2 plan +to do this work. The split is purely mechanical relative to the +mapping table above. diff --git a/docs/plans/0001c-async-trait-sunset.md b/docs/plans/0001c-async-trait-sunset.md new file mode 100644 index 0000000..f9d8938 --- /dev/null +++ b/docs/plans/0001c-async-trait-sunset.md @@ -0,0 +1,847 @@ +# Sub-Plan 0001c: Sunset the `async-trait` crate dependency + +**Status**: Draft +**Branch**: `feat/storage-trait-phase1` (Phase 1 amendment, PR A) +**Depends on**: +- `0001a-trait-rewrite.md` (rewrites `MemoryStore` / `LocalMemoryStore` and + the SQLite impl; lands first) +- `0001b-sqlite-split.md` (moves `sqlite.rs` into `sqlite/`; lands second) + +**Related**: `docs/adr/0002-phase-2-execution.md` (decision D1 closing line: +"async-trait dependency stays in Cargo.toml only if other code uses it; +otherwise removed"). This sub-plan operationalises the removal. + +--- + +## Context + +This is the third and final Phase 1 amendment sub-plan. Sub-plan `0001a` +rewrote `MemoryStore` / `LocalMemoryStore` using +`#[trait_variant::make(MemoryStore: Send)]` and dropped the +`#[async_trait::async_trait]` attribute from the SQLite impl block. +Sub-plan `0001b` then split `sqlite.rs` into a `sqlite/` directory; the +trait impl now lives in `sqlite/trait_impl.rs`. After `0001a` lands, the +only remaining `async_trait` usage in the workspace is the embedder pair +(`embedder/mod.rs` declares the trait; `embedder/fastembed.rs` implements +it). This sub-plan rewrites those two files following the exact pattern +from `0001a`, then removes `async-trait = "0.1"` from +`crates/vestige-core/Cargo.toml`. End state: zero `async_trait` references +anywhere under `crates/`, zero direct dependency on the `async-trait` +crate, workspace tests and clippy green. + +The rewrite is mechanically tiny -- one trait declaration, one impl block, +one Cargo.toml line -- but it is gated behind `0001a` and `0001b` so the +trait-rewrite pattern is already settled and so the SQLite trait impl +attribute has already been dropped. Doing the embedder rewrite without +that pre-work would leave the `async-trait` dep behind for the SQLite +side and force the Cargo.toml deletion into a separate commit later. + +--- + +## Scope + +### In scope + +- Rewrite `LocalEmbedder` declaration in + `crates/vestige-core/src/embedder/mod.rs` to use + `#[trait_variant::make(Embedder: Send)] pub trait LocalEmbedder`. +- Delete the `pub use LocalEmbedder as Embedder;` alias from the same file. + The `Embedder` symbol becomes the trait that `trait_variant::make` emits + at the same module path, so the existing + `pub use embedder::{Embedder, ..., LocalEmbedder};` line in + `crates/vestige-core/src/lib.rs:167` keeps working untouched. +- Drop the `#[async_trait::async_trait]` attribute from the + `FastembedEmbedder` impl block in + `crates/vestige-core/src/embedder/fastembed.rs`. +- Update doc comments on the trait declaration to describe + `trait_variant` rather than `async_trait`. +- Remove `async-trait = "0.1"` from + `crates/vestige-core/Cargo.toml` (line 119 area). Use + `cargo rm async-trait` from inside the crate directory. +- Verify with `grep -rn "async_trait" crates/` returning zero hits. + +### Out of scope + +- Any change to the `MemoryStore` trait or `SqliteMemoryStore` impl; + those were handled by `0001a`. +- Any file moves in `embedder/` (no parallel of `0001b` is required; + `embedder/` already has the `mod.rs` + `fastembed.rs` shape). +- Touching `crates/vestige-mcp/` or any cognitive module. None of them + hold `Arc` or `Box` in production. +- Renaming the `Embedder` / `LocalEmbedder` symbols or changing the + re-exports in `crates/vestige-core/src/lib.rs`. + +--- + +## Prerequisites + +### State assumed at start + +- `0001a` is merged onto the branch. After `0001a`: + - `crates/vestige-core/src/storage/memory_store.rs` declares + `#[trait_variant::make(MemoryStore: Send)] pub trait LocalMemoryStore`. + - The SQLite impl block has no `#[async_trait::async_trait]` attribute. + - `grep -rn async_trait crates/` returns exactly three hits, all in + `crates/vestige-core/src/embedder/` (two in `mod.rs`, one in + `fastembed.rs`), and one Cargo.toml hit. +- `0001b` is merged onto the branch. After `0001b`: + - `crates/vestige-core/src/storage/sqlite.rs` no longer exists as a + single file; the impl lives in `crates/vestige-core/src/storage/sqlite/trait_impl.rs`. + - The embedder files are untouched. + +### Required crates + +| Crate | Version | Action | +|----------------|---------|-----------------------------------------------------------------| +| `trait-variant`| `0.1` | Already declared (line 117 of Cargo.toml). Verify present. | +| `async-trait` | `0.1` | Remove. Only the two embedder files still use it after `0001a`. | + +### Workspace-wide audit before starting + +Run from `/home/delandtj/prppl/vestige-phase2/` (or the equivalent +worktree where this sub-plan executes): + +```bash +grep -rn "async_trait\|async-trait" crates/ tests/ +``` + +Expected hits before this sub-plan starts (after `0001a` + `0001b`): + +``` +crates/vestige-core/Cargo.toml:119:async-trait = "0.1" +crates/vestige-core/src/embedder/mod.rs:24:/// `#[async_trait::async_trait]` makes every `async fn` return a +crates/vestige-core/src/embedder/mod.rs:27:#[async_trait::async_trait] +crates/vestige-core/src/embedder/mod.rs:56:/// Both names refer to the same `async_trait`-annotated trait. +crates/vestige-core/src/embedder/fastembed.rs:44:#[async_trait::async_trait] +``` + +Five hits across two source files and one Cargo.toml. After this sub-plan, +the same grep must return zero hits. + +```bash +grep -rn "async-trait\|async_trait" --include="Cargo.toml" crates/ +``` + +Expected: exactly one hit (`crates/vestige-core/Cargo.toml:119`). No other +workspace crate declares `async-trait` as a direct dependency. This is +the precondition that lets us delete the line cleanly. + +--- + +## Files Touched + +### Trait declaration (vestige-core) + +| File | Lines (approx) | Change | +|-------------------------------------------------|----------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `crates/vestige-core/src/embedder/mod.rs` | 21-57 | Replace `#[async_trait::async_trait] pub trait LocalEmbedder: Send + Sync + 'static` with `#[trait_variant::make(Embedder: Send)] pub trait LocalEmbedder: Sync + 'static`. Delete the `pub use LocalEmbedder as Embedder;` alias on line 57. Update doc comments (lines 21-26, 55-56). | + +### Impl block (vestige-core) + +| File | Lines (approx) | Change | +|-------------------------------------------------|----------------|--------------------------------------------------------------------------------------------------------------| +| `crates/vestige-core/src/embedder/fastembed.rs` | 44 | Delete the `#[async_trait::async_trait]` attribute. Keep the `impl LocalEmbedder for FastembedEmbedder { ... }` body verbatim. No `Box::pin`, no `'async_trait` lifetimes, no manual `Pin>`. | + +### Other Embedder impls + +None. `grep -rn "impl.*LocalEmbedder\|impl.*Embedder for" crates/ tests/` +returns exactly one production hit: +`crates/vestige-core/src/embedder/fastembed.rs:45: impl LocalEmbedder for FastembedEmbedder`. +There is no test mock implementing `Embedder` in the test tree (the only +test that touches the trait, `tests/phase_1/embedder_trait.rs`, uses the +concrete `FastembedEmbedder` boxed as `Box`). + +### Call sites (production) + +Verified by: + +```bash +grep -rn "dyn Embedder\|dyn LocalEmbedder" crates/ tests/ --include="*.rs" +grep -rn "Box\|Arc" crates/ tests/ --include="*.rs" +grep -rn "use.*Embedder" crates/ tests/ --include="*.rs" +``` + +Production call sites that may need verification (and the expected change +for each, even though we have already verified that none need an edit): + +| File | Use | Required change | +|------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------|-----------------| +| `crates/vestige-core/src/lib.rs:167` | `pub use embedder::{Embedder, EmbedderError, EmbedderResult, FastembedEmbedder, LocalEmbedder};` | None. Both names still exist at `crate::embedder::*` after the rewrite; `Embedder` is now the `trait_variant`-generated trait, `LocalEmbedder` is the source-of-truth trait. The re-export keeps resolving. | +| `crates/vestige-core/src/embedder/fastembed.rs:7` | `use super::{EmbedderError, EmbedderResult, LocalEmbedder};` | None. `LocalEmbedder` is still the source-of-truth trait name. | +| `crates/vestige-core/src/embedder/mod.rs:5` | `pub use fastembed::FastembedEmbedder;` | None. Concrete type, untouched. | +| `crates/vestige-mcp/src/**` | No file imports `Embedder` or `LocalEmbedder` by name; none hold `Arc` or `Box`. | None. Verified by grep returning empty for `dyn Embedder` and `dyn LocalEmbedder` under `crates/vestige-mcp/`. | +| Cognitive modules under `crates/vestige-core/src/advanced/` and `crates/vestige-core/src/neuroscience/` | No file imports `Embedder` or `LocalEmbedder` by name. `advanced/adaptive_embedding.rs` defines its own unrelated `AdaptiveEmbedder` struct. | None. The name collision is purely surface-level; the two types live in different modules and never resolve to each other. | +| `crates/vestige-core/src/embeddings/**` | No file imports `Embedder` or `LocalEmbedder`. The `EmbeddingService` struct is what `FastembedEmbedder` wraps internally. | None. | + +The production audit returns zero files that need editing. + +### Call sites (tests) + +| File | Lines | Use | Required change | +|------------------------------------------------------------|-------|--------------------------------------------------------------------|-----------------| +| `tests/phase_1/embedder_trait.rs` | 3, 19 | `use vestige_core::embedder::{Embedder, FastembedEmbedder};`
      `let e: Box = Box::new(FastembedEmbedder::new());` | None. `Embedder` is the `trait_variant`-generated Send variant; `Box` keeps compiling. `FastembedEmbedder` implements `LocalEmbedder`; the blanket `impl Embedder for T` that `trait_variant::make` emits gives the boxing for free. | + +The test audit returns zero files that need editing. + +### Cargo dependency cleanup + +| File | Lines | Change | +|-------------------------------------|-----------|-----------------------------------------------------------------------------------------------------| +| `crates/vestige-core/Cargo.toml` | 119 | Remove `async-trait = "0.1"`. Run `cargo rm async-trait` from inside `crates/vestige-core/` so `Cargo.lock` updates atomically with the manifest. | + +### Documentation + +| File | Change | +|---------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------| +| `crates/vestige-core/src/embedder/mod.rs` | Rewrite the trait-level doc comment (lines 21-26) and the `pub use` doc comment (lines 55-56) to describe `trait_variant`, not `async_trait`. See "Trait declaration rewrite" below for the exact new text. | +| `CLAUDE.md` | No change. The repo-level architecture notes do not name the trait attribute. | + +--- + +## Trait Declaration Rewrite + +### Before (state after `0001a` and `0001b` land) + +`crates/vestige-core/src/embedder/mod.rs:1-58`: + +```rust +//! Text-to-vector encoding trait. Pluggable per-install. + +mod fastembed; + +pub use fastembed::FastembedEmbedder; + +/// Error returned by every `Embedder` method. +#[non_exhaustive] +#[derive(Debug, thiserror::Error)] +pub enum EmbedderError { + #[error("embedder initialization failed: {0}")] + Init(String), + #[error("embedding generation failed: {0}")] + EmbedFailed(String), + #[error("invalid input: {0}")] + InvalidInput(String), +} + +pub type EmbedderResult = std::result::Result; + +/// Pluggable embedder. The storage layer NEVER calls fastembed directly; +/// callers compute vectors via this trait and pass them into `MemoryStore`. +/// +/// `#[async_trait::async_trait]` makes every `async fn` return a +/// `Pin>`, which is required for `Box` +/// and `Arc` to be dyn-compatible. +#[async_trait::async_trait] +pub trait LocalEmbedder: Send + Sync + 'static { + async fn embed(&self, text: &str) -> EmbedderResult>; + + fn model_name(&self) -> &str; + + fn dimension(&self) -> usize; + + /// Stable blake3 hash of (model_name || dimension || vestige-core crate version). + /// Lowercase hex, 64 chars. + /// + /// Used by `MemoryStore::register_model` to detect silent model drift + /// (e.g. a fastembed minor upgrade that changes vector output). + fn model_hash(&self) -> String; + + async fn embed_batch(&self, texts: &[&str]) -> EmbedderResult>>; + + /// Returns the `ModelSignature` describing this embedder. Convenience + /// wrapper over the three accessors above. + fn signature(&self) -> crate::storage::ModelSignature { + crate::storage::ModelSignature { + name: self.model_name().to_string(), + dimension: self.dimension(), + hash: self.model_hash(), + } + } +} + +/// Type alias: `Embedder` is the dyn-compatible, Send+Sync variant. +/// Both names refer to the same `async_trait`-annotated trait. +pub use LocalEmbedder as Embedder; +``` + +### After + +`crates/vestige-core/src/embedder/mod.rs:1-55` (approximately): + +```rust +//! Text-to-vector encoding trait. Pluggable per-install. + +mod fastembed; + +pub use fastembed::FastembedEmbedder; + +/// Error returned by every `Embedder` method. +#[non_exhaustive] +#[derive(Debug, thiserror::Error)] +pub enum EmbedderError { + #[error("embedder initialization failed: {0}")] + Init(String), + #[error("embedding generation failed: {0}")] + EmbedFailed(String), + #[error("invalid input: {0}")] + InvalidInput(String), +} + +pub type EmbedderResult = std::result::Result; + +/// Pluggable embedder. The storage layer NEVER calls fastembed directly; +/// callers compute vectors via this trait and pass them into `MemoryStore`. +/// +/// `LocalEmbedder` is the source-of-truth trait. The +/// `#[trait_variant::make(Embedder: Send)]` attribute auto-generates an +/// `Embedder` variant whose returned futures are `Send`, so +/// `Box` and `Arc` are usable on tokio/axum +/// runtimes, while `Box` remains usable on single- +/// threaded executors and thread-local backends. +/// +/// Every method is native async-fn-in-trait (stable on MSRV 1.91); no +/// per-call heap allocation, no boxed futures at the static-dispatch +/// boundary. +#[trait_variant::make(Embedder: Send)] +pub trait LocalEmbedder: Sync + 'static { + async fn embed(&self, text: &str) -> EmbedderResult>; + + fn model_name(&self) -> &str; + + fn dimension(&self) -> usize; + + /// Stable blake3 hash of (model_name || dimension || vestige-core crate version). + /// Lowercase hex, 64 chars. + /// + /// Used by `MemoryStore::register_model` to detect silent model drift + /// (e.g. a fastembed minor upgrade that changes vector output). + fn model_hash(&self) -> String; + + async fn embed_batch(&self, texts: &[&str]) -> EmbedderResult>>; + + /// Returns the `ModelSignature` describing this embedder. Convenience + /// wrapper over the three accessors above. + fn signature(&self) -> crate::storage::ModelSignature { + crate::storage::ModelSignature { + name: self.model_name().to_string(), + dimension: self.dimension(), + hash: self.model_hash(), + } + } +} +``` + +### Both halves of the macro-generated output (for reviewer clarity) + +`trait_variant::make(Embedder: Send)` expands the source-of-truth +`LocalEmbedder` declaration above into the equivalent of: + +```rust +// 1. The source-of-truth trait, exactly as written. +pub trait LocalEmbedder: Sync + 'static { + fn embed(&self, text: &str) -> impl Future>>; + fn model_name(&self) -> &str; + fn dimension(&self) -> usize; + fn model_hash(&self) -> String; + fn embed_batch(&self, texts: &[&str]) -> impl Future>>>; + fn signature(&self) -> crate::storage::ModelSignature { /* default impl unchanged */ } +} + +// 2. The generated Send variant. +pub trait Embedder: Sync + 'static { + fn embed(&self, text: &str) -> impl Future>> + Send; + fn model_name(&self) -> &str; + fn dimension(&self) -> usize; + fn model_hash(&self) -> String; + fn embed_batch(&self, texts: &[&str]) -> impl Future>>> + Send; + fn signature(&self) -> crate::storage::ModelSignature { /* default impl unchanged */ } +} + +// 3. The blanket impl that wires any LocalEmbedder + Send through to Embedder. +impl Embedder for T +where + T: LocalEmbedder + Send, + // (all returned futures of LocalEmbedder's async fns are required to be Send, + // which is satisfied for FastembedEmbedder -- see "Risks" below) +{ /* forwarders */ } +``` + +Notes: + +- The `pub use LocalEmbedder as Embedder;` line on the current + `embedder/mod.rs:57` is **deleted** entirely. `Embedder` is now the + trait that `trait_variant::make` emits at the same module path; the + re-export in `crates/vestige-core/src/lib.rs:167` + (`pub use embedder::{Embedder, ..., LocalEmbedder};`) keeps resolving + unchanged. +- `Sync + 'static` on `LocalEmbedder` (and no `Send` bound on the trait + itself) mirrors the `0001a` pattern for `LocalMemoryStore`. The current + trait carries `Send + Sync + 'static`; the rewrite drops the `Send` + bound from the local variant. `Box` is `Sync` but + not `Send`; `Box` (the generated variant) is `Send + Sync`. +- `trait_variant` 0.1 does **not** require any attribute on the impl + block. The attribute lives only on the trait declaration. See next + section. + +--- + +## Impl Block Migration + +`trait_variant` 0.1 attaches the attribute only to the trait declaration. +The impl side is plain `impl LocalEmbedder for FastembedEmbedder`; no +attribute on the impl, no `#[trait_variant::make(Embedder: Send)]` on the +impl block. The macro auto-generates the blanket +`impl Embedder for T`, so any concrete type that +implements `LocalEmbedder` automatically also implements `Embedder` +provided it is `Send`. + +`FastembedEmbedder` is `Send + Sync` because: + +- `inner: EmbeddingService` is `Send + Sync` (it wraps fastembed's + `TextEmbedding` which is `Send + Sync` after fastembed 4.x; verified + in `crates/vestige-core/src/embeddings/mod.rs`). +- `cached_hash: std::sync::OnceLock` is `Send + Sync` for `T: Send + Sync`. +- The `#[cfg(not(feature = "embeddings"))]` branch carries only + `cached_hash`, which is unconditionally `Send + Sync`. + +No new bound is needed. + +### Before + +`crates/vestige-core/src/embedder/fastembed.rs:38-100` (relevant header): + +```rust +impl Default for FastembedEmbedder { + fn default() -> Self { + Self::new() + } +} + +#[async_trait::async_trait] +impl LocalEmbedder for FastembedEmbedder { + async fn embed(&self, text: &str) -> EmbedderResult> { + // ... body unchanged ... + } + + fn model_name(&self) -> &str { /* ... */ } + fn dimension(&self) -> usize { /* ... */ } + fn model_hash(&self) -> String { /* ... */ } + + async fn embed_batch(&self, texts: &[&str]) -> EmbedderResult>> { + // ... body unchanged ... + } +} +``` + +### After + +`crates/vestige-core/src/embedder/fastembed.rs:38-99` (one fewer line): + +```rust +impl Default for FastembedEmbedder { + fn default() -> Self { + Self::new() + } +} + +impl LocalEmbedder for FastembedEmbedder { + async fn embed(&self, text: &str) -> EmbedderResult> { + // ... body unchanged ... + } + + fn model_name(&self) -> &str { /* ... */ } + fn dimension(&self) -> usize { /* ... */ } + fn model_hash(&self) -> String { /* ... */ } + + async fn embed_batch(&self, texts: &[&str]) -> EmbedderResult>> { + // ... body unchanged ... + } +} +``` + +Diff is exactly one removed line (the `#[async_trait::async_trait]` +attribute on line 44). Every method body, every `async fn` signature, +every `use` statement inside the impl block stays verbatim. No +`Box::pin(async move { ... })`, no manual `Pin>`, no +`'async_trait` lifetime markers; native async-fn-in-trait does this +directly. + +### Why the impl block does not need an attribute + +`trait_variant::make` generates two things from the source trait +(see the "macro-generated output" subsection above): + +1. The source trait itself (`LocalEmbedder`), with native async fns. +2. A second trait (`Embedder`) whose method signatures return + `impl Future + Send` instead of `impl Future`, + plus a blanket impl wiring concrete types through. + +Both are emitted at the macro-call site. `FastembedEmbedder` writes one +impl block (against `LocalEmbedder`); the macro-generated blanket +guarantees `FastembedEmbedder: Embedder` for free. The +`Box` cast on `tests/phase_1/embedder_trait.rs:19` keeps +type-checking unchanged. + +--- + +## Call Site Audit + +Verified via, from the phase2 worktree root: + +```bash +grep -rn "async_trait\|LocalEmbedder\|dyn Embedder" crates/ +grep -rn "use.*Embedder" crates/ tests/ --include="*.rs" +grep -rn "Box\|Arc\|&dyn Embedder" crates/ tests/ --include="*.rs" +grep -rn "Box\|Arc\|&dyn LocalEmbedder" crates/ tests/ --include="*.rs" +grep -rn "impl LocalEmbedder for\|impl Embedder for" crates/ tests/ --include="*.rs" +``` + +### Files that reference the trait object form + +Exactly one, test-only: + +| File | Line | Use | Required change | +|--------------------------------------|------|------------------------------------------------------------------------------------------|-----------------| +| `tests/phase_1/embedder_trait.rs` | 3 | `use vestige_core::embedder::{Embedder, FastembedEmbedder};` | None. `Embedder` is the generated Send variant at the same path. | +| `tests/phase_1/embedder_trait.rs` | 19 | `let e: Box = Box::new(FastembedEmbedder::new());` | None. `FastembedEmbedder: LocalEmbedder + Send` -> blanket gives `: Embedder` -> `Box` is well-formed. | + +### Files that import `Embedder` or `LocalEmbedder` by name + +| File | Line | Use | Required change | +|-----------------------------------------------------|------|----------------------------------------------------------------------------------------------------------------|-----------------| +| `crates/vestige-core/src/lib.rs` | 167 | `pub use embedder::{Embedder, EmbedderError, EmbedderResult, FastembedEmbedder, LocalEmbedder};` | None. Both names still resolve. | +| `crates/vestige-core/src/embedder/mod.rs` | 5 | `pub use fastembed::FastembedEmbedder;` | None. | +| `crates/vestige-core/src/embedder/fastembed.rs` | 7 | `use super::{EmbedderError, EmbedderResult, LocalEmbedder};` | None. | +| `tests/phase_1/embedder_trait.rs` | 3 | `use vestige_core::embedder::{Embedder, FastembedEmbedder};` | None. | + +### Files that implement the trait + +| File | Line | Impl | Required change | +|-----------------------------------------------------|------|-----------------------------------------------------------------------|----------------------------------------------| +| `crates/vestige-core/src/embedder/fastembed.rs` | 45 | `impl LocalEmbedder for FastembedEmbedder` (currently `#[async_trait]`) | Drop the `#[async_trait::async_trait]` attr. | + +No other impls exist. There is no test mock implementing `Embedder` or +`LocalEmbedder` anywhere in the workspace. + +### Files that import `async_trait` directly + +After `0001a` lands, only the embedder pair: + +``` +crates/vestige-core/src/embedder/mod.rs:24 (doc comment) +crates/vestige-core/src/embedder/mod.rs:27 (attribute) +crates/vestige-core/src/embedder/mod.rs:56 (doc comment) +crates/vestige-core/src/embedder/fastembed.rs:44 (attribute) +``` + +Plus the Cargo manifest: + +``` +crates/vestige-core/Cargo.toml:119:async-trait = "0.1" +``` + +### Production files that hold a concrete embedder + +`FastembedEmbedder` is constructed and used by concrete name (not via +trait object) in: the dashboard / MCP layer if it needs to embed query +strings ad-hoc. None of those call sites need an edit because the +concrete type is what they hold, and the concrete type is untouched by +this sub-plan. + +### Conclusion + +| Category | Count | +|--------------------------------------------------|-------| +| Production source files modified | 2 | +| Test source files modified | 0 | +| Cargo manifests modified | 1 | +| Production source files importing `Embedder` / `LocalEmbedder` (verified unchanged) | 3 | +| Test source files importing `Embedder` (verified unchanged) | 1 | +| Direct `async_trait` uses outside the embedder module after `0001a` | 0 | + +--- + +## Cargo.toml Change + +From inside `crates/vestige-core/`: + +```bash +cargo rm async-trait +``` + +This removes line 119 of `Cargo.toml` and updates `Cargo.lock` in one +step. Manual editing is acceptable as a fallback if `cargo rm` is +unavailable in the agent environment; in that case, follow up with +`cargo check -p vestige-core` to refresh the lockfile. + +### Verification + +```bash +# Direct dependency must be gone. +grep -rn "async-trait\|async_trait" --include="Cargo.toml" crates/ +# Expected: empty. + +# Transitive presence is permitted (e.g. via a third-party crate). +cargo tree -p vestige-core --depth 2 | grep async-trait +# Expected: empty for the direct edges; if a sub-dependency still pulls +# async-trait transitively, the output may contain it deeper than depth 2, +# which is fine. We only care about removing the DIRECT edge. +``` + +If `cargo tree --depth 2` returns any `async-trait` line, inspect with +`cargo tree -p vestige-core -i async-trait` to see what is pulling it. +Acceptable parents: any third-party crate. Unacceptable parent: anything +under `vestige-*`, which would mean a missed file. + +--- + +## Commit Sequence + +Three commits, each green on +`cargo test -p vestige-core --features embeddings,vector-search` and +`cargo test -p vestige-core --no-default-features`. + +### Commit 1: rewrite LocalEmbedder trait declaration + +- Touches: `crates/vestige-core/src/embedder/mod.rs` only. +- Action: replace lines 21-57 per the "Trait Declaration Rewrite" + section above. Delete the `pub use LocalEmbedder as Embedder;` line. +- Green after: `cargo check -p vestige-core` (the impl block in + `fastembed.rs` still has its `#[async_trait::async_trait]` attribute; + the macro is harmless when applied to a trait that the impl block + targets by path, because async_trait rewrites the impl's async fns + into boxed-future fns whose signatures still match the native-async + declarations after trait_variant lowering, just as it did for the + SQLite intermediate state in `0001a`'s commit 1). + + **Mitigation if check fails between commits 1 and 2:** combine the + two into a single commit. The split is offered for review convenience; + the build must be green after every commit lands. + +### Commit 2: drop `#[async_trait::async_trait]` from FastembedEmbedder impl + +- Touches: `crates/vestige-core/src/embedder/fastembed.rs` only. +- Action: delete line 44 (`#[async_trait::async_trait]`). +- Green after: + - `cargo test -p vestige-core --features embeddings,vector-search`. + - `cargo test -p vestige-core --no-default-features` (the + `#[cfg(not(feature = "embeddings"))]` branches inside the impl now + stand on their own). + - Phase 1 integration test: `cargo test --test embedder_trait + --features embeddings,vector-search`. + +### Commit 3: drop the async-trait dependency + +- Touches: `crates/vestige-core/Cargo.toml` (plus `Cargo.lock` as a + side effect). +- Action: from inside `crates/vestige-core/`, run `cargo rm async-trait`. +- Green after: `cargo build --workspace --all-targets` and + `cargo test --workspace`. +- Final hard ASCII gate: `! grep -rn "async_trait" crates/` must exit + with status 0 (i.e. the inverted grep finds nothing). + +### Combined alternative + +Commits 1 and 2 may fold into a single commit if the per-step split +feels artificial (the patterns are identical to `0001a`'s commits 3 +and 4). Commit 3 (the Cargo.toml removal) should stay separate so the +dependency-removal diff is visible in isolation. + +--- + +## Verification + +Every command runs from the repo root unless noted otherwise. + +```bash +# 1. Vestige-core, default features (embeddings + vector-search). +cargo test -p vestige-core --features embeddings,vector-search + +# 2. Vestige-core, minimal features (no embeddings, no vector-search). +cargo test -p vestige-core --no-default-features + +# 3. Workspace build, all targets (catches any feature-gated regression +# in the vestige-mcp tools tree). +cargo build --workspace --all-targets + +# 4. Whole-workspace test (vestige-mcp 406 tests + vestige-core 352 +# tests per the CLAUDE.md baseline). +cargo test --workspace + +# 5. Phase 1 embedder integration test (the trait-shape contract). +cargo test --test embedder_trait --features embeddings,vector-search + +# 6. Clippy gate, deny warnings (matches Phase 1 PR policy). +cargo clippy --workspace --all-targets --features embeddings,vector-search -- -D warnings + +# 7. Hard ASCII gate -- async_trait must be gone from source. +! grep -rn "async_trait" crates/ +# Inverted grep: exit 0 iff grep found nothing. + +# 8. Hard ASCII gate -- async-trait must be gone from manifests. +! grep -rn "async-trait" --include="Cargo.toml" crates/ + +# 9. Confirm trait_variant attribute is in place at the embedder. +grep -rn "trait_variant::make" crates/vestige-core/src/embedder/ +# Expected: exactly one hit, in embedder/mod.rs. + +# 10. Workspace-wide trait_variant audit (should match the count after +# 0001a -- two hits total, one for storage, one for embedder). +grep -rn "trait_variant::make" crates/vestige-core/src/ +# Expected: two hits. +``` + +Expected outcomes: + +- Command 1: 352 vestige-core tests pass (matches baseline). +- Command 2: smaller test count, all pass. +- Command 3: workspace builds in dev mode for all targets. +- Command 4: 758 total tests pass (matches CLAUDE.md baseline). +- Command 5: `embedder_trait` integration test passes. The + `fastembed_implements_embedder_trait` assertion (`let e: Box = ...`) is the canary; if `trait_variant::make` failed to + emit the `Embedder` Send variant, this fails to compile. +- Command 6: zero clippy warnings. +- Command 7: empty output. `async_trait` is fully gone from source. +- Command 8: empty output. `async-trait` is fully gone from manifests. +- Command 9: one hit. +- Command 10: two hits. + +--- + +## Acceptance Criteria + +A reviewer should be able to check every box: + +- [ ] `crates/vestige-core/src/embedder/mod.rs` declares the embedder + trait with `#[trait_variant::make(Embedder: Send)] pub trait + LocalEmbedder: Sync + 'static`, no `async_trait` attribute, no + `Send` bound on `LocalEmbedder` itself. +- [ ] `crates/vestige-core/src/embedder/mod.rs` no longer contains + `pub use LocalEmbedder as Embedder;`. +- [ ] `crates/vestige-core/src/embedder/fastembed.rs` declares + `impl LocalEmbedder for FastembedEmbedder` with no attribute on + the impl block. +- [ ] `crates/vestige-core/Cargo.toml` does not declare `async-trait` + as a direct dependency. +- [ ] `grep -rn "async_trait" crates/` returns zero hits. +- [ ] `grep -rn "async-trait" --include="Cargo.toml" crates/` returns + zero hits. +- [ ] `grep -rn "trait_variant::make" crates/vestige-core/src/` returns + exactly two hits (storage trait + embedder trait). +- [ ] All 758 workspace tests pass (`cargo test --workspace`). +- [ ] `tests/phase_1/embedder_trait.rs` compiles and passes with the + `Box` cast intact. +- [ ] `cargo clippy --workspace --all-targets --features + embeddings,vector-search -- -D warnings` is clean. +- [ ] No file under `crates/vestige-mcp/` or under + `crates/vestige-core/src/{neuroscience,advanced,consolidation, + codebase,memory,embeddings}/` was modified by this sub-plan. +- [ ] `Cargo.lock` was updated as a side effect of `cargo rm async-trait` + (it must no longer reference `async-trait`). +- [ ] Doc comments on the embedder trait declaration describe + `trait_variant`, not `async_trait`. + +--- + +## Risks and Mitigations + +- **`trait_variant::make` requires returned futures to be `Send` for the + blanket `impl Embedder for T`. If any + `async fn embed`/`embed_batch` body inside `FastembedEmbedder` captures + a non-Send local, the blanket impl fails to type-check.** + Mitigation: the existing impl bodies call `self.inner.embed(text)` / + `self.inner.embed_batch(texts)`, where `inner: EmbeddingService` is + `Send + Sync` (verified in `crates/vestige-core/src/embeddings/mod.rs`). + No `.await` points exist inside the bodies in either feature branch; + the `EmbeddingService::embed` calls are synchronous. The futures are + trivially `Send`. If a future change introduces a non-Send local + (e.g. an `Rc` or a non-Send guard), the blanket impl will surface that + as a compile error at the dyn cast in `tests/phase_1/embedder_trait.rs`, + which is the correct outcome. +- **The macro's blanket impl interacts oddly with the default `signature` + method.** + Mitigation: `signature` is a synchronous method returning + `crate::storage::ModelSignature`, with no `Send` or `async` concerns. + `trait_variant::make` emits it on both variants as-is. The existing + Phase 1 test `signature_matches_memory_store_registry` exercises this + path and is part of the verification step. +- **`Box` cast in `tests/phase_1/embedder_trait.rs` fails + to resolve after the rewrite.** + Mitigation: the rewrite preserves the `Embedder` symbol at the same + module path; only its provenance changes (now generated by + `trait_variant::make` instead of by `pub use LocalEmbedder as + Embedder;`). The macro is specifically designed so that the generated + trait is dyn-compatible at the Send-bound boundary. Verified by the + identical pattern already working for `MemoryStore` after `0001a`. +- **`cargo rm async-trait` updates `Cargo.lock` but accidentally bumps + other crates.** + Mitigation: run `cargo rm async-trait` and then immediately inspect + the resulting `Cargo.lock` diff. The expected diff is the removal of + the `[[package]] name = "async-trait"` block and its hash. Anything + else is a red flag and should be reverted before committing + (`git checkout -- Cargo.lock` then `cargo update -p async-trait + --precise=remove` -- or fall back to manual edit + `cargo check`). +- **A new workspace crate added in parallel with this work declares + `async-trait` and the dependency removal silently re-introduces it + later.** + Mitigation: the verification step `grep -rn "async-trait" + --include="Cargo.toml" crates/` is part of the acceptance criteria; a + rebase that reintroduces the line will fail this gate. +- **MCP server uses `Embedder` somewhere we missed.** + Mitigation: full workspace grep (`grep -rn "Embedder" crates/`) + returns no hits inside `crates/vestige-mcp/` for the trait names; the + MCP layer uses the concrete `EmbeddingService` from + `crates/vestige-core/src/embeddings/` for ad-hoc embedding calls. The + trait surface is purely internal to `vestige-core`. + +--- + +## Out-of-Band Notes + +- **No other workspace crate declares `async-trait` as a direct + dependency.** Verified by + `grep -rn "async-trait" --include="Cargo.toml" crates/` returning + exactly one hit at `crates/vestige-core/Cargo.toml:119`. There is + nothing to clean up in `crates/vestige-mcp/Cargo.toml` or elsewhere. +- **Order matters across the three Phase 1 amendment sub-plans:** + `0001a` (trait rewrite) -> `0001b` (sqlite split) -> `0001c` (this + one, async-trait sunset). Reversing the order is possible in + principle but would force re-editing the embedder rewrite twice and + leaves the `async-trait` dep behind until very late. +- **This sub-plan amends `feat/storage-trait-phase1` (tip 790c0c8 plus + whatever commits `0001a` and `0001b` added).** The branch has not + been opened upstream yet, so amending in place is safe; no force-push + to a public PR. +- **After this sub-plan lands, the branch is reviewed and merged before + Phase 2 sub-plans (`0002a-` through `0002i-`) begin implementation.** + Phase 2 introduces no async-trait usage; the Postgres backend follows + the same `trait_variant::make` pattern (see ADR 0002 D1). +- **`trait-variant` 0.1 stays in `Cargo.toml`.** It is the only crate + this sub-plan keeps; `async-trait` is the only one it removes. + +--- + +## Self-Contained `/goal` Brief + +For a fresh Claude Code session executing this sub-plan without prior +conversation context: + +1. Check out branch `feat/storage-trait-phase1` (or a worktree off + of it after `0001a` and `0001b` are merged into it). +2. Read this file (`docs/plans/0001c-async-trait-sunset.md`) in full. +3. Read `docs/plans/0001a-trait-rewrite.md` sections "Trait declaration + rewrite" and "Impl block migration" -- they document the exact + pattern this sub-plan mirrors for the embedder. +4. Run the prerequisite audit grep listed under "Prerequisites". If it + returns more than the five hits documented there, stop and report; + the upstream state does not match what this sub-plan assumes. +5. Execute Commit 1 (rewrite `embedder/mod.rs`), then Commit 2 (drop + the attribute on the FastembedEmbedder impl), then Commit 3 + (`cargo rm async-trait`). Run the verification commands listed + above after each commit; do not proceed if any test or clippy gate + fails. +6. Verify every box in "Acceptance Criteria" is ticked. +7. Report file paths touched, test counts, and the final two grep + results (commands 7 and 8 from "Verification") in the closing + message. From 9ef8afdb20337d08cb5489078ae49eec8c7c1cf1 Mon Sep 17 00:00:00 2001 From: Jan De Landtsheer Date: Wed, 27 May 2026 09:35:58 +0200 Subject: [PATCH 07/23] docs(plans): add Phase 2 sub-plans 0002a-0002i + supersession notice Nine Phase 2 sub-plans operationalising ADR 0002 against the Phase 2 master plan, each sized to fit a focused implementation session and handed to Claude Code as a /goal brief without requiring the agent to load the master plan. Order of execution (each depends on the previous unless noted): - 0002a-skeleton-and-feature-gate.md -- postgres-backend Cargo feature + PgMemoryStore skeleton with todo!() bodies. D1+D2. - 0002b-pool-and-config.md -- PgPool builder, VestigeConfig/ PostgresConfig, vestige.toml loader wired into vestige-mcp. D3+D7 (master plan numbering). - 0002c-migrations.md -- sqlx migrations 0001_init/0002_hnsw including D7 (users/groups/memberships, owner/visibility/shared_with_groups) and D8 (codebase column). SQLite V15 parity migration. D4. - 0002d-store-impl-bodies.md -- real CRUD + registry bodies; trivial fts_search/vector_search bodies. D2+D6. - 0002e-hybrid-search.md -- one-statement RRF query. D5. - 0002f-migrate-cli.md -- vestige migrate copy (SQLite -> Postgres), --dry-run, idempotent re-runs, --allow-source-upgrade for pre-V15 sources. D8+D10. - 0002g-reembed.md -- vestige migrate reembed (offline rebuild). D9 + D10 reembed arm. Ships resolve_embedder helper as a workaround for the missing Embedder::from_name(&str) constructor. - 0002h-testing-and-benches.md -- testcontainers harness, six integration test files, Criterion bench at 1k/100k. D14+D15. - 0002i-runbook.md -- operator-facing deployment + day-2 runbook. D16. Supersession notice added to the master plan (0002-phase-2-postgres- backend.md) pointing at ADR 0002; body retained as archival reference. PR B carries this commit plus the previous two (ADR 0002 + Phase 1 amendment sub-plans); no code change. --- docs/plans/0002-phase-2-postgres-backend.md | 8 + docs/plans/0002a-skeleton-and-feature-gate.md | 554 ++++++ docs/plans/0002b-pool-and-config.md | 886 +++++++++ docs/plans/0002c-migrations.md | 1119 +++++++++++ docs/plans/0002d-store-impl-bodies.md | 1771 +++++++++++++++++ docs/plans/0002e-hybrid-search.md | 825 ++++++++ docs/plans/0002f-migrate-cli.md | 1045 ++++++++++ docs/plans/0002g-reembed.md | 843 ++++++++ docs/plans/0002h-testing-and-benches.md | 1223 ++++++++++++ docs/plans/0002i-runbook.md | 724 +++++++ 10 files changed, 8998 insertions(+) create mode 100644 docs/plans/0002a-skeleton-and-feature-gate.md create mode 100644 docs/plans/0002b-pool-and-config.md create mode 100644 docs/plans/0002c-migrations.md create mode 100644 docs/plans/0002d-store-impl-bodies.md create mode 100644 docs/plans/0002e-hybrid-search.md create mode 100644 docs/plans/0002f-migrate-cli.md create mode 100644 docs/plans/0002g-reembed.md create mode 100644 docs/plans/0002h-testing-and-benches.md create mode 100644 docs/plans/0002i-runbook.md diff --git a/docs/plans/0002-phase-2-postgres-backend.md b/docs/plans/0002-phase-2-postgres-backend.md index 3fe28f2..ed2a186 100644 --- a/docs/plans/0002-phase-2-postgres-backend.md +++ b/docs/plans/0002-phase-2-postgres-backend.md @@ -1,5 +1,13 @@ # Phase 2 Plan: PostgreSQL Backend +> **Supersession Notice (2026-05-26):** This master plan is now archival. Execution is governed by: +> - **ADR**: [`docs/adr/0002-phase-2-execution.md`](../adr/0002-phase-2-execution.md) -- binding decisions +> - **Sub-plans** (executable briefs): +> - Phase 1 amendment: [0001a-trait-rewrite.md](0001a-trait-rewrite.md), [0001b-sqlite-split.md](0001b-sqlite-split.md), [0001c-async-trait-sunset.md](0001c-async-trait-sunset.md) +> - Phase 2: 0002a..0002i (skeleton, pool+config, migrations, store impl, hybrid search, migrate CLI, reembed, tests+benches, runbook) +> +> **Deltas vs body**: trait uses `trait_variant`, error type is `MemoryStoreError`/`MemoryStoreResult`, `connect` is `(url, max_connections)` only, the core table is `knowledge_nodes` (not `memories`) and gains `owner_user_id` + `visibility` + `shared_with_groups` + `codebase`, plus `users`/`groups`/`group_memberships` tables. See ADR 0002 D1-D8. + **Status**: Draft **Depends on**: Phase 1 (MemoryStore + Embedder traits, embedding_model registry, domain columns) **Related**: docs/adr/0001-pluggable-storage-and-network-access.md (Phase 2), docs/prd/001-getting-centralized-vestige.md, docs/plans/local-dev-postgres-setup.md (local cluster provisioning) diff --git a/docs/plans/0002a-skeleton-and-feature-gate.md b/docs/plans/0002a-skeleton-and-feature-gate.md new file mode 100644 index 0000000..74032dc --- /dev/null +++ b/docs/plans/0002a-skeleton-and-feature-gate.md @@ -0,0 +1,554 @@ +# Phase 2 Sub-Plan 0002a -- Skeleton and Feature Gate + +**Status**: Ready +**Depends on**: Phase 1 amendment (sub-plans `0001a-trait-rewrite.md` and +`0001b-sqlite-split.md`) merged. Specifically: +- `MemoryStore` trait declared with `#[trait_variant::make(MemoryStore: Send)]`, + generating a non-Send `LocalMemoryStore` companion trait. The + `pub use MemoryStore as LocalMemoryStore` alias from Phase 1 is gone. +- `crates/vestige-core/src/storage/sqlite.rs` has been split into + `crates/vestige-core/src/storage/sqlite/` with the same public surface. + +This sub-plan covers Phase 2 master-plan deliverables D1 and D2 only: +the `postgres-backend` Cargo feature gate and a compilable `PgMemoryStore` +skeleton whose trait method bodies are `todo!()`. No real Postgres code, no +migrations, no SQL. Later sub-plans (`0002b-pool-and-config.md`, +`0002c-migrations.md`, `0002d-store-impl-bodies.md`, ...) fill the bodies in. + +The success criterion is a clean build under both feature-flag configurations, +nothing more. + +--- + +## Context + +ADR 0002 D4 commits Phase 2 to a `crates/vestige-core/src/storage/postgres/` +directory from day one. The seven other files in that directory +(`pool.rs`, `migrations.rs`, `registry.rs`, `search.rs`, `migrate_cli.rs`, +`reembed.rs`) belong to subsequent sub-plans. This sub-plan creates only +`crates/vestige-core/src/storage/postgres/mod.rs` so the rest can be added +incrementally without breaking the build. + +Per ADR 0002 D2, `PgMemoryStore::connect` mirrors `SqliteMemoryStore::new`: +no `Embedder` argument. The pgvector typmod DDL +(`ALTER TABLE memories ALTER COLUMN embedding TYPE vector($N)`) lives inside +the trait method `register_model`, invoked by the caller after construction. +In this sub-plan `register_model` is a `todo!()` body; `0002c-migrations.md` +and `0002d-store-impl-bodies.md` provide the real implementation. + +The trait surface in `crates/vestige-core/src/storage/memory_store.rs` is the +source of truth for method signatures. Do NOT copy signatures from the master +plan -- they are stale in places (for example, master plan 0002 D2 lists +`remove_edge` as three-arg `(source, target, edge_type)`; the live trait has +two args `(source, target)`). + +--- + +## Cargo manifest changes + +Two optional crates and one new feature flag. Use `cargo add` per the global +CLAUDE.md preference; do not hand-edit `Cargo.toml`. + +```bash +cd crates/vestige-core + +cargo add sqlx@0.8 --optional --no-default-features \ + --features runtime-tokio,tls-rustls,postgres,uuid,chrono,json,migrate,macros + +cargo add pgvector@0.4 --optional --features sqlx +``` + +After both commands, open `crates/vestige-core/Cargo.toml` and add the +`postgres-backend` feature line in the `[features]` block. Place it after +the `metal` feature, before `[dependencies]`: + +```toml +# Postgres backend (mutually compilable with the SQLite backend; default OFF). +# Compile with: --features postgres-backend +postgres-backend = ["dep:sqlx", "dep:pgvector"] +``` + +Do NOT add `tokio-stream`, `futures`, `indicatif`, or `toml` in this sub-plan. +The master plan D1 lists them in the `postgres-backend` feature for +convenience, but their consumers (streaming migrate, progress bar, config +parsing) land in later sub-plans. Adding them here pulls dead weight into the +feature gate. + +Do NOT add the `vestige-mcp` pass-through feature in this sub-plan either. +The MCP crate gets its `postgres-backend` feature in `0002b-pool-and-config.md` +when `MemoryStoreConfig` lands and the binary needs a knob to pick a backend. + +Verify the diff to `crates/vestige-core/Cargo.toml` looks like this and only +this: + +```toml +[features] +# ...existing features unchanged... +postgres-backend = ["dep:sqlx", "dep:pgvector"] + +[dependencies] +# ...existing deps unchanged... +sqlx = { version = "0.8", default-features = false, features = [ + "runtime-tokio", "tls-rustls", "postgres", "uuid", "chrono", + "json", "migrate", "macros", +], optional = true } +pgvector = { version = "0.4", features = ["sqlx"], optional = true } +``` + +The exact ordering of the two new lines inside `[dependencies]` is not +significant; `cargo add` places them at the end. Leave the placement that +`cargo add` produces. + +--- + +## Storage module export + +Edit `crates/vestige-core/src/storage/mod.rs` to expose the new module behind +the feature flag. Two lines change. + +Add to the module-declaration block (after `mod sqlite;`): + +```rust +#[cfg(feature = "postgres-backend")] +mod postgres; +``` + +Add to the re-export block (after the `pub use sqlite::{ ... }` block): + +```rust +#[cfg(feature = "postgres-backend")] +pub use postgres::PgMemoryStore; +``` + +Nothing else in `storage/mod.rs` changes. The `Storage` alias still points at +`SqliteMemoryStore`; the SQLite re-export block is untouched. + +--- + +## Postgres module skeleton + +Create `crates/vestige-core/src/storage/postgres/mod.rs` with the full content +below. This is the only new file in this sub-plan. + +```rust +#![cfg(feature = "postgres-backend")] +//! Postgres-backed implementation of `MemoryStore`. +//! +//! Skeleton only. Every trait method is `todo!()`. Real bodies land in +//! subsequent Phase 2 sub-plans: +//! - `0002b-pool-and-config.md`: pool construction and config wiring +//! - `0002c-migrations.md`: sqlx migration files and `init`/`register_model` +//! - `0002d-store-impl-bodies.md`: CRUD, scheduling, edges, domains +//! - `0002e-hybrid-search.md`: RRF query and search bodies +//! +//! The directory grows companion files (`pool.rs`, `migrations.rs`, +//! `registry.rs`, `search.rs`, `migrate_cli.rs`, `reembed.rs`) in those +//! sub-plans; this skeleton only creates `mod.rs`. + +use chrono::{DateTime, Utc}; +use sqlx::PgPool; +use uuid::Uuid; + +use crate::storage::memory_store::{ + Domain, HealthStatus, LocalMemoryStore, MemoryEdge, MemoryRecord, MemoryStoreResult, + ModelSignature, SchedulingState, SearchQuery, SearchResult, StoreStats, +}; + +/// Postgres-backed implementation of `MemoryStore`. +/// +/// Cheaply cloneable. Methods take `&self`; interior state lives inside the +/// `PgPool` (which already provides `Sync` via `Arc` internally). +#[derive(Clone)] +pub struct PgMemoryStore { + pool: PgPool, + /// Embedding vector dimension. Set to 0 in the skeleton; populated by + /// `register_model` in `0002d-store-impl-bodies.md` once the pgvector + /// `ALTER COLUMN TYPE vector(N)` DDL lands. + embedding_dim: i32, +} + +impl PgMemoryStore { + /// Construct a new store from a connection URL. + /// + /// Mirrors `SqliteMemoryStore::new`: no `Embedder` argument. The pgvector + /// `ALTER TABLE memories ALTER COLUMN embedding TYPE vector($N)` DDL lives + /// inside `register_model`, not here. The caller (cognitive engine + /// bootstrap, migrate CLI, tests) invokes `register_model` after this + /// returns, identically to the SQLite path. + /// + /// Real body lands in `0002b-pool-and-config.md` (pool construction) and + /// `0002c-migrations.md` (initial migration run). + pub async fn connect(_url: &str, _max_connections: u32) -> MemoryStoreResult { + todo!("PgMemoryStore::connect lands in 0002b-pool-and-config.md") + } + + /// Low-level constructor for tests: supply an existing pool, skip migrate. + /// + /// Real body lands in `0002b-pool-and-config.md`. + pub async fn from_pool(_pool: PgPool) -> MemoryStoreResult { + todo!("PgMemoryStore::from_pool lands in 0002b-pool-and-config.md") + } + + /// Accessor used by migrate/reembed CLI. + pub fn pool(&self) -> &PgPool { + &self.pool + } + + /// Currently-registered vector dimension. Returns 0 until `register_model` + /// has been called (real body: `0002d-store-impl-bodies.md`). + pub fn embedding_dim(&self) -> i32 { + self.embedding_dim + } +} + +// trait_variant::make on the trait declaration generates two traits: +// - `MemoryStore` (Send-bound) +// - `LocalMemoryStore` (non-Send companion) +// The implementer writes `impl LocalMemoryStore for ...` plainly; the Send +// variant is generated automatically from the non-Send impl. +impl LocalMemoryStore for PgMemoryStore { + // --- Lifecycle --- + async fn init(&self) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::init lands in 0002c-migrations.md") + } + + async fn health_check(&self) -> MemoryStoreResult { + todo!("PgMemoryStore::health_check lands in 0002d-store-impl-bodies.md") + } + + // --- Embedding model registry --- + async fn registered_model(&self) -> MemoryStoreResult> { + todo!("PgMemoryStore::registered_model lands in 0002d-store-impl-bodies.md") + } + + async fn register_model(&self, _sig: &ModelSignature) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::register_model lands in 0002d-store-impl-bodies.md") + } + + // --- CRUD --- + async fn insert(&self, _record: &MemoryRecord) -> MemoryStoreResult { + todo!("PgMemoryStore::insert lands in 0002d-store-impl-bodies.md") + } + + async fn get(&self, _id: Uuid) -> MemoryStoreResult> { + todo!("PgMemoryStore::get lands in 0002d-store-impl-bodies.md") + } + + async fn update(&self, _record: &MemoryRecord) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::update lands in 0002d-store-impl-bodies.md") + } + + async fn delete(&self, _id: Uuid) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::delete lands in 0002d-store-impl-bodies.md") + } + + // --- Search --- + async fn search(&self, _query: &SearchQuery) -> MemoryStoreResult> { + todo!("PgMemoryStore::search lands in 0002e-hybrid-search.md") + } + + async fn fts_search( + &self, + _text: &str, + _limit: usize, + ) -> MemoryStoreResult> { + todo!("PgMemoryStore::fts_search lands in 0002e-hybrid-search.md") + } + + async fn vector_search( + &self, + _embedding: &[f32], + _limit: usize, + ) -> MemoryStoreResult> { + todo!("PgMemoryStore::vector_search lands in 0002e-hybrid-search.md") + } + + // --- FSRS Scheduling --- + async fn get_scheduling( + &self, + _memory_id: Uuid, + ) -> MemoryStoreResult> { + todo!("PgMemoryStore::get_scheduling lands in 0002d-store-impl-bodies.md") + } + + async fn update_scheduling(&self, _state: &SchedulingState) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::update_scheduling lands in 0002d-store-impl-bodies.md") + } + + async fn get_due_memories( + &self, + _before: DateTime, + _limit: usize, + ) -> MemoryStoreResult> { + todo!("PgMemoryStore::get_due_memories lands in 0002d-store-impl-bodies.md") + } + + // --- Graph (spreading activation) --- + async fn add_edge(&self, _edge: &MemoryEdge) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::add_edge lands in 0002d-store-impl-bodies.md") + } + + async fn get_edges( + &self, + _node_id: Uuid, + _edge_type: Option<&str>, + ) -> MemoryStoreResult> { + todo!("PgMemoryStore::get_edges lands in 0002d-store-impl-bodies.md") + } + + async fn remove_edge(&self, _source: Uuid, _target: Uuid) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::remove_edge lands in 0002d-store-impl-bodies.md") + } + + async fn get_neighbors( + &self, + _node_id: Uuid, + _depth: usize, + ) -> MemoryStoreResult> { + todo!("PgMemoryStore::get_neighbors lands in 0002d-store-impl-bodies.md") + } + + // --- Domains (Phase 1: stubs return empty; full impl in Phase 4) --- + async fn list_domains(&self) -> MemoryStoreResult> { + todo!("PgMemoryStore::list_domains lands in 0002d-store-impl-bodies.md") + } + + async fn get_domain(&self, _id: &str) -> MemoryStoreResult> { + todo!("PgMemoryStore::get_domain lands in 0002d-store-impl-bodies.md") + } + + async fn upsert_domain(&self, _domain: &Domain) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::upsert_domain lands in 0002d-store-impl-bodies.md") + } + + async fn delete_domain(&self, _id: &str) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::delete_domain lands in 0002d-store-impl-bodies.md") + } + + async fn classify(&self, _embedding: &[f32]) -> MemoryStoreResult> { + todo!("PgMemoryStore::classify lands in 0002d-store-impl-bodies.md") + } + + // --- Bulk / Maintenance --- + async fn count(&self) -> MemoryStoreResult { + todo!("PgMemoryStore::count lands in 0002d-store-impl-bodies.md") + } + + async fn get_stats(&self) -> MemoryStoreResult { + todo!("PgMemoryStore::get_stats lands in 0002d-store-impl-bodies.md") + } + + async fn vacuum(&self) -> MemoryStoreResult<()> { + todo!("PgMemoryStore::vacuum lands in 0002d-store-impl-bodies.md") + } +} +``` + +Notes on the skeleton: + +- The file-level `#![cfg(feature = "postgres-backend")]` means the whole file + vanishes when the feature is off. The `mod postgres;` line in + `storage/mod.rs` is itself feature-gated, so this is belt-and-braces; both + gates are needed because the file-level attribute is what allows the file to + use `sqlx::PgPool` unconditionally inside it. +- `EmbeddingModelDescriptor` (a separate Postgres-internal type that the + master plan sketched on the struct) is dropped. The trait surface already + carries `ModelSignature` for the registry round-trip; the registry storage + layout is a private concern of `registry.rs`, which is added later. Keep + `PgMemoryStore` minimal until a real consumer needs the extra type. +- The struct only carries `pool` and `embedding_dim`. The model descriptor + field from the master plan sketch goes away with `EmbeddingModelDescriptor`. + If `register_model` later needs to cache the descriptor on the struct, it + can be added then; the skeleton does not speculate. +- The two trivial accessors (`pool`, `embedding_dim`) get real bodies. Every + other method is `todo!()` so it returns `!` and trivially coerces to the + declared return type at the type checker; this is what lets the build pass + with no error variants and no SQL. + +--- + +## Connect signature + +Per ADR 0002 D2: + +```rust +pub async fn connect(url: &str, max_connections: u32) -> MemoryStoreResult; +pub async fn from_pool(pool: PgPool) -> MemoryStoreResult; +``` + +No `&dyn Embedder` argument. This deliberately differs from master plan 0002, +which predates the Phase 1 freeze. The pgvector-specific DDL +(`ALTER TABLE memories ALTER COLUMN embedding TYPE vector($N)`) does not run +inside `connect`; it runs inside `register_model(&ModelSignature)`, which the +caller invokes after `connect` returns. + +In this sub-plan `register_model` is `todo!()`. The real body lands in +`0002d-store-impl-bodies.md` after `0002c-migrations.md` ships the +`0001_init.up.sql` migration that creates the `memories` table with a +placeholder `embedding vector` column (no typmod), against which +`register_model` later runs the typmod stamp. + +--- + +## Error variant additions: deferred + +`MemoryStoreError` does NOT gain `Postgres(sqlx::Error)` or +`Migrate(sqlx::migrate::MigrateError)` in this sub-plan. + +The reason is mechanical: `todo!()` evaluates to the never type `!`, which +coerces to any `MemoryStoreResult` regardless of the error variants +available. With every method body a `todo!()`, the skeleton has no expression +that needs to convert a `sqlx::Error` or `sqlx::migrate::MigrateError` into +`MemoryStoreError`. Adding the variants here would mean adding the +`#[cfg(feature = "postgres-backend")]` and `#[from]` plumbing to +`memory_store.rs` with no consumer yet -- dead code at every level except the +enum definition itself. + +`0002d-store-impl-bodies.md` introduces both variants in the same commit that +turns the first `todo!()` into a real `sqlx::query!` call. That keeps the +diff to `memory_store.rs` next to the first usage site, which is easier to +review than adding variants ahead of need. + +For reference, the variants that will be added in `0002d-store-impl-bodies.md` +look like this: + +```rust +#[cfg(feature = "postgres-backend")] +#[error("postgres error: {0}")] +Postgres(#[from] sqlx::Error), + +#[cfg(feature = "postgres-backend")] +#[error("postgres migration error: {0}")] +Migrate(#[from] sqlx::migrate::MigrateError), +``` + +Do not pre-add them here. + +--- + +## Verification + +Run these commands from the workspace root. All four must produce a clean +build, zero warnings on the diff-affected files, no test changes. + +```bash +# 1. Default features (SQLite backend, postgres-backend OFF). Must build. +cargo build --workspace --all-targets + +# 2. Workspace clippy with default features. Must be clean. +cargo clippy --workspace --all-targets -- -D warnings + +# 3. Postgres feature enabled. Must build. +cargo build -p vestige-core --features postgres-backend + +# 4. Clippy with postgres feature enabled. Must be clean. +cargo clippy -p vestige-core --features postgres-backend --all-targets -- -D warnings +``` + +Expected outcomes: + +- `cargo build --workspace --all-targets` finishes with no compilation of + `sqlx` or `pgvector` (both are optional, no consumer with default features). + The `postgres` module is excluded entirely via `#[cfg]`. +- `cargo build -p vestige-core --features postgres-backend` compiles `sqlx`, + `pgvector`, and `storage/postgres/mod.rs`. The build succeeds because every + trait method is `todo!()`; nothing actually runs SQL. +- Both `clippy` invocations pass with `-D warnings`. The `todo!()` macro does + not emit a `dead_code` lint by itself, and the trivial accessors are used by + later sub-plans (clippy on the postgres feature alone may flag them as + unused if you run with `--lib` only; the `--all-targets` form keeps tests + and benches in scope so this does not fire). +- If clippy flags `unused_variables` on the underscore-prefixed parameters in + the `todo!()` bodies, the underscore prefix is already the standard + suppression; if a future clippy version disagrees, add + `#[allow(unused_variables)]` to the impl block, not to each method. + +Tests are not modified in this sub-plan. The unit tests in +`memory_store.rs` (`memory_store_error_from_storage_error`, +`model_signature_serde_round_trip`, `memory_record_serde_round_trip`) keep +passing because no type they touch changes. + +Do NOT run `cargo test` against the postgres feature -- there is no Postgres +running and no test exercises `PgMemoryStore` yet. The build check is the +contract. + +--- + +## Acceptance criteria + +1. `crates/vestige-core/Cargo.toml` declares `sqlx = "0.8"` and + `pgvector = "0.4"` as optional dependencies with the exact feature sets + specified above. +2. `crates/vestige-core/Cargo.toml` declares `postgres-backend = ["dep:sqlx", + "dep:pgvector"]` and nothing else inside that feature. +3. `crates/vestige-mcp/Cargo.toml` is unchanged. +4. `crates/vestige-core/src/storage/mod.rs` adds exactly two + feature-gated lines: `mod postgres;` and `pub use postgres::PgMemoryStore;`. + No other change. +5. `crates/vestige-core/src/storage/postgres/mod.rs` exists and contains the + `PgMemoryStore` struct, `impl PgMemoryStore` block with real `pool` and + `embedding_dim` accessors and `todo!()` bodies for `connect` and + `from_pool`, and the full `impl LocalMemoryStore for PgMemoryStore` block + with `todo!()` for every trait method. +6. The trait impl method signatures match `memory_store.rs` byte-for-byte + (including `remove_edge(&self, source: Uuid, target: Uuid)` two-arg form, + not the three-arg form from the master plan). +7. `MemoryStoreError` is unchanged. +8. No other files in the crate are touched. No new files in + `storage/postgres/` besides `mod.rs`. +9. The four verification commands above all succeed. + +--- + +## Commit sequence + +One commit is recommended. The two changes (Cargo manifest + module skeleton) +do not compile in isolation: the manifest change without the skeleton produces +unused-optional-dep warnings, and the skeleton without the manifest change +fails to find `sqlx`. Splitting them adds no review value, since the second +commit is the one that has to compile cleanly. + +```bash +git add crates/vestige-core/Cargo.toml \ + crates/vestige-core/Cargo.lock \ + crates/vestige-core/src/storage/mod.rs \ + crates/vestige-core/src/storage/postgres/mod.rs + +git commit -m "feat(storage): scaffold postgres-backend feature and PgMemoryStore skeleton + +Adds the postgres-backend Cargo feature gating sqlx 0.8 and pgvector 0.4. +Introduces crates/vestige-core/src/storage/postgres/mod.rs with the +PgMemoryStore struct, connect/from_pool/pool/embedding_dim, and a trait impl +whose method bodies are todo!() pending later Phase 2 sub-plans. + +Builds clean with default features (SQLite only) and with --features +postgres-backend. No runtime behaviour change. + +Refs ADR 0002 D1, D2, D4." +``` + +If for any reason the manifest change must be reviewed separately (for +example, a security review of the sqlx version pin), split as: + +1. `cargo add` for sqlx and pgvector + manual feature line in Cargo.toml. + Build with default features will pass but `--features postgres-backend` + will fail (no module to satisfy the feature). This is acceptable for a + short-lived intermediate commit. +2. `storage/mod.rs` edits + `storage/postgres/mod.rs` creation. Both builds + pass. + +Default to the single-commit form unless asked to split. + +--- + +## Followups + +- `0002b-pool-and-config.md` adds `pool.rs`, `PostgresConfig`, and the + `vestige-mcp` `postgres-backend` pass-through feature. +- `0002c-migrations.md` adds `crates/vestige-core/migrations/postgres/` with + `0001_init.{up,down}.sql` and `0002_hnsw.{up,down}.sql`, plus + `postgres/migrations.rs` invoking `sqlx::migrate!`. `init()` body lands here. +- `0002d-store-impl-bodies.md` introduces the two `MemoryStoreError` variants + and replaces every `todo!()` in CRUD / scheduling / edges / domains / + registry with real `sqlx::query!` bodies. +- `0002e-hybrid-search.md` fills the three search bodies via the RRF query. diff --git a/docs/plans/0002b-pool-and-config.md b/docs/plans/0002b-pool-and-config.md new file mode 100644 index 0000000..9941413 --- /dev/null +++ b/docs/plans/0002b-pool-and-config.md @@ -0,0 +1,886 @@ +# Sub-plan 0002b -- Pool construction and VestigeConfig + +**Status**: Draft +**Master plan**: [0002-phase-2-postgres-backend.md](0002-phase-2-postgres-backend.md) +**ADR**: [0002-phase-2-execution.md](../adr/0002-phase-2-execution.md) +**Predecessor**: [0002a-skeleton-and-feature-gate.md](0002a-skeleton-and-feature-gate.md) + +--- + +## Context + +This sub-plan delivers two of the master plan's deliverables now that the +`0002a` skeleton has landed: + +- **D3** -- pool construction in + `crates/vestige-core/src/storage/postgres/pool.rs`. Replaces the `todo!()` + body of `PgMemoryStore::connect` with a real `PgPool` builder that reads a + `PostgresConfig`. Registry/migration calls remain `todo!()`; those are + filled in by sub-plans `0002c` (migrations) and `0002d` (store bodies + + registry). +- **D7** -- new module `crates/vestige-core/src/config.rs` containing + `VestigeConfig`, `StorageConfig`, `SqliteConfig`, `PostgresConfig`, + `EmbeddingsConfig`, plus a `ConfigError` enum and a loader that reads + `vestige.toml`. The loader is wired into `vestige-mcp` so the running + server picks SQLite or Postgres at startup based on the config file. + +After this sub-plan: + +- `cargo build` (default features, no `postgres-backend`) compiles and the + MCP server still defaults to SQLite when no `vestige.toml` is present. +- `cargo build --features postgres-backend` compiles, with + `PgMemoryStore::connect` now wiring through `pool.rs` (registry/migration + still `todo!()` until `0002c` and `0002d`). +- A `vestige.toml` example can be round-tripped through + `VestigeConfig::load` in a unit test. + +This sub-plan deliberately does NOT: + +- Add migrations (`0002c`). +- Fill in real CRUD/search bodies on `PgMemoryStore` (`0002d`, `0002e`). +- Add env-var override support (Phase 3 concern, called out in master plan + D7 behaviour notes). + +--- + +## Dependencies + +- `0002a-skeleton-and-feature-gate.md` must be merged. That sub-plan creates + `crates/vestige-core/src/storage/postgres/mod.rs` with: + - `PgMemoryStore` struct holding `pool: PgPool`. + - `PgMemoryStore::connect(url: &str, max_connections: u32) -> MemoryStoreResult` + body = `todo!()`. + - `PgMemoryStore::from_pool(pool: PgPool) -> MemoryStoreResult` + body = `todo!()`. + - The trait impl block with all methods routed to `todo!()`. + - The `postgres-backend` feature gate on the module declaration in + `storage/mod.rs`. + +This sub-plan extends those bodies and adds two siblings: `pool.rs` and +`registry.rs` (the latter is a stub here, real body in `0002d`). + +--- + +## Audit step (do this first) + +Before adding `config.rs`, confirm there is no existing top-level config +loader. Run from the repo root: + +```bash +rg -nF 'VestigeConfig' crates/ +rg -nF 'toml::from_str' crates/ +rg -n '#\[derive.*Deserialize.*\]' crates/vestige-core/src/ +``` + +If a `VestigeConfig` struct already exists from Phase 1, treat the "Config +module" section below as additive: extend the existing struct rather than +creating a new file. The cross-cut additions in that case are: + +1. Add the `StorageConfig` enum (gated and ungated branches). +2. Add `SqliteConfig`, `PostgresConfig`. +3. Add the `default_path()` helper if missing. +4. Add `ConfigError` if a different error enum is used today (rename/extend + instead of duplicating). + +As of the audit at the time of this writing, no `VestigeConfig` exists in +`vestige-core`. `directories::ProjectDirs` is already used in +`vestige-core/src/embeddings/local.rs` and in +`vestige-mcp/src/protocol/auth.rs`, so the `directories` crate is already a +workspace dependency -- no new dep there. + +--- + +## Cargo manifest additions + +Add `toml` to `vestige-core`. `serde` and `thiserror` are already present +from Phase 1; `directories` is already a transitive dep but we add it +explicitly so `default_path()` is supported. + +```bash +cd crates/vestige-core +cargo add toml@0.8 +cargo add directories@5 +``` + +No new deps on `vestige-mcp`; it already depends on `vestige-core`. + +`sqlx` is already added by `0002a` behind the `postgres-backend` feature +with `runtime-tokio`, `tls-rustls`, `postgres`, `uuid`, `chrono`, +`json`, `macros`, `migrate` features. The pool module only uses what is +already pulled in. + +--- + +## Config module + +**File**: `crates/vestige-core/src/config.rs` (new). +**Re-exported** from `crates/vestige-core/src/lib.rs` as `pub mod config;` plus +`pub use config::{VestigeConfig, StorageConfig, SqliteConfig, EmbeddingsConfig, ConfigError};` +and `#[cfg(feature = "postgres-backend")] pub use config::PostgresConfig;`. + +Full content: + +```rust +//! Vestige top-level configuration. +//! +//! Loaded from `~/.vestige/vestige.toml` by default; the path is overridable +//! via `VestigeConfig::load(Some(&path))`. Parsing uses serde + toml; the +//! `[storage]` section is internally-tagged on a `backend` field so a single +//! enum dispatch picks SQLite or Postgres. + +use std::path::{Path, PathBuf}; + +use serde::Deserialize; + +/// Top-level configuration as parsed from `vestige.toml`. +#[derive(Debug, Clone, Deserialize, Default)] +#[serde(default, deny_unknown_fields)] +pub struct VestigeConfig { + pub embeddings: EmbeddingsConfig, + pub storage: StorageConfig, + /// Reserved for Phase 3. Empty in Phase 2. + pub server: ServerConfig, + /// Reserved for Phase 3. Empty in Phase 2. + pub auth: AuthConfig, +} + +/// Embedding provider selection. +#[derive(Debug, Clone, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct EmbeddingsConfig { + /// Provider key. Phase 2 ships `"fastembed"` only. + pub provider: String, + /// Model name. For fastembed this is e.g. `"nomic-ai/nomic-embed-text-v1.5"`. + pub model: String, +} + +impl Default for EmbeddingsConfig { + fn default() -> Self { + Self { + provider: "fastembed".to_string(), + model: crate::DEFAULT_EMBEDDING_MODEL.to_string(), + } + } +} + +/// Storage backend selection. Internally tagged on the `backend` field: +/// +/// ```toml +/// [storage] +/// backend = "sqlite" +/// +/// [storage.sqlite] +/// path = "/home/user/.vestige/vestige.db" +/// ``` +/// +/// or, when compiled with `--features postgres-backend`: +/// +/// ```toml +/// [storage] +/// backend = "postgres" +/// +/// [storage.postgres] +/// url = "postgres://vestige:secret@localhost:5432/vestige" +/// max_connections = 10 +/// acquire_timeout_secs = 30 +/// ``` +#[derive(Debug, Clone, Deserialize)] +#[serde(tag = "backend", rename_all = "lowercase", deny_unknown_fields)] +pub enum StorageConfig { + Sqlite(SqliteConfig), + #[cfg(feature = "postgres-backend")] + Postgres(PostgresConfig), +} + +impl Default for StorageConfig { + fn default() -> Self { + StorageConfig::Sqlite(SqliteConfig::default()) + } +} + +/// SQLite backend configuration. +#[derive(Debug, Clone, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct SqliteConfig { + /// Path to the `vestige.db` file. If unset, the SqliteMemoryStore + /// constructor picks its platform default location. + #[serde(default)] + pub path: Option, +} + +impl Default for SqliteConfig { + fn default() -> Self { + Self { path: None } + } +} + +/// Postgres backend configuration. Only present when the `postgres-backend` +/// Cargo feature is enabled. +#[cfg(feature = "postgres-backend")] +#[derive(Debug, Clone, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct PostgresConfig { + /// `postgres://user:pass@host:port/db` -- forwarded to + /// `PgConnectOptions::from_str`. + pub url: String, + /// Pool size. Default `10`. + #[serde(default)] + pub max_connections: Option, + /// Acquire timeout in seconds. Default `30`. Set above 30 so + /// testcontainer-based test fixtures do not race. + #[serde(default)] + pub acquire_timeout_secs: Option, +} + +/// Reserved for Phase 3 (bind address, ports, TLS). +#[derive(Debug, Clone, Default, Deserialize)] +#[serde(default, deny_unknown_fields)] +pub struct ServerConfig {} + +/// Reserved for Phase 3 (API keys, claims). +#[derive(Debug, Clone, Default, Deserialize)] +#[serde(default, deny_unknown_fields)] +pub struct AuthConfig {} + +/// Errors raised while locating, reading, or parsing `vestige.toml`. +#[derive(Debug, thiserror::Error)] +pub enum ConfigError { + #[error("config io: {0}")] + Io(#[from] std::io::Error), + #[error("config toml: {0}")] + Toml(#[from] toml::de::Error), + #[error("config dir: could not locate user home")] + NoHome, + #[error("invalid config: {0}")] + Invalid(String), +} + +impl VestigeConfig { + /// Load config from `path` or from `default_path()` when `None`. + /// + /// Returns `VestigeConfig::default()` (SQLite + fastembed defaults) when + /// the file does not exist. Any other I/O or parse failure is surfaced + /// as a `ConfigError`. + pub fn load(path: Option<&Path>) -> Result { + let resolved: PathBuf = match path { + Some(p) => p.to_path_buf(), + None => Self::default_path()?, + }; + + match std::fs::read_to_string(&resolved) { + Ok(text) => { + let cfg: VestigeConfig = toml::from_str(&text)?; + cfg.validate()?; + Ok(cfg) + } + Err(e) if e.kind() == std::io::ErrorKind::NotFound => { + Ok(Self::default()) + } + Err(e) => Err(ConfigError::Io(e)), + } + } + + /// `~/.vestige/vestige.toml`. The directory is NOT created here; loading + /// a missing file falls back to defaults. + pub fn default_path() -> Result { + let dirs = directories::ProjectDirs::from("", "vestige", "vestige") + .ok_or(ConfigError::NoHome)?; + // ProjectDirs::config_dir() varies per OS. Vestige convention is + // ~/.vestige/vestige.toml on Linux/macOS regardless of XDG, so we + // build the path off the home dir explicitly. + let home = directories::UserDirs::new() + .ok_or(ConfigError::NoHome)? + .home_dir() + .to_path_buf(); + let _ = dirs; // keep the dep wired; future Phase 3 may use it + Ok(home.join(".vestige").join("vestige.toml")) + } + + /// Light cross-field validation. Heavy validation (URL parsing, + /// directory existence) is left to the backend constructors. + fn validate(&self) -> Result<(), ConfigError> { + if self.embeddings.provider.is_empty() { + return Err(ConfigError::Invalid( + "embeddings.provider must not be empty".into(), + )); + } + if self.embeddings.model.is_empty() { + return Err(ConfigError::Invalid( + "embeddings.model must not be empty".into(), + )); + } + match &self.storage { + StorageConfig::Sqlite(_) => {} + #[cfg(feature = "postgres-backend")] + StorageConfig::Postgres(cfg) => { + if cfg.url.is_empty() { + return Err(ConfigError::Invalid( + "storage.postgres.url must not be empty".into(), + )); + } + } + } + Ok(()) + } +} +``` + +### Serde behaviour with `postgres-backend` off + +`StorageConfig` is generated by serde only for the variants that are +compiled in. When `postgres-backend` is off and the user writes: + +```toml +[storage] +backend = "postgres" + +[storage.postgres] +url = "..." +``` + +serde returns a `toml::de::Error` of the form +`unknown variant `postgres`, expected `sqlite``. That error path goes +through `From for ConfigError`, surfacing as +`ConfigError::Toml(..)`. The MCP server prints this once at startup and +exits with a non-zero code; there is no panic. + +To make the error friendlier we wrap that specific case in a clearer +message via a thin post-parse check. Add this small helper after parsing +in `load()`: + +```rust +// (Inside the Ok(text) arm in load(), wrapping the parse step.) +let cfg: VestigeConfig = match toml::from_str(&text) { + Ok(c) => c, + Err(e) => { + let msg = e.to_string(); + if msg.contains("unknown variant `postgres`") { + return Err(ConfigError::Invalid( + "storage.backend = \"postgres\" requires building with --features postgres-backend".into(), + )); + } + return Err(ConfigError::Toml(e)); + } +}; +``` + +This keeps the strict default deny_unknown_fields behaviour while giving the +user a one-line action item. + +--- + +## Pool module + +**File**: `crates/vestige-core/src/storage/postgres/pool.rs` (new). + +```rust +#![cfg(feature = "postgres-backend")] + +//! `PgPool` construction for the Postgres backend. +//! +//! Pool defaults follow ADR 0002 D2 + master plan D3: +//! - max_connections = 10 +//! - acquire_timeout = 30s (must exceed testcontainer warmup) +//! - idle_timeout = 600s +//! - max_lifetime = 1800s +//! - test_before_acquire = false (cheap queries; saves a roundtrip) + +use std::str::FromStr; +use std::time::Duration; + +use sqlx::postgres::{PgConnectOptions, PgPoolOptions}; +use sqlx::{ConnectOptions, PgPool}; + +use crate::config::PostgresConfig; +use crate::storage::memory_store::{MemoryStoreError, MemoryStoreResult}; + +const DEFAULT_MAX_CONNECTIONS: u32 = 10; +const DEFAULT_ACQUIRE_TIMEOUT_SECS: u64 = 30; +const IDLE_TIMEOUT_SECS: u64 = 600; +const MAX_LIFETIME_SECS: u64 = 1800; +const STATEMENT_CACHE_CAPACITY: usize = 256; + +/// Build a Postgres connection pool from a `PostgresConfig`. Does NOT run +/// migrations or stamp the embedding registry; those are the caller's job +/// (`PgMemoryStore::connect`). +pub async fn build_pool(cfg: &PostgresConfig) -> MemoryStoreResult { + let opts = PgConnectOptions::from_str(&cfg.url) + .map_err(MemoryStoreError::from)? + .application_name("vestige") + .statement_cache_capacity(STATEMENT_CACHE_CAPACITY) + .log_statements(tracing::log::LevelFilter::Debug); + + let max_conn = cfg.max_connections.unwrap_or(DEFAULT_MAX_CONNECTIONS); + let acquire = cfg + .acquire_timeout_secs + .unwrap_or(DEFAULT_ACQUIRE_TIMEOUT_SECS); + + let pool = PgPoolOptions::new() + .max_connections(max_conn) + .min_connections(0) + .acquire_timeout(Duration::from_secs(acquire)) + .idle_timeout(Some(Duration::from_secs(IDLE_TIMEOUT_SECS))) + .max_lifetime(Some(Duration::from_secs(MAX_LIFETIME_SECS))) + .test_before_acquire(false) + .connect_with(opts) + .await + .map_err(MemoryStoreError::from)?; + + Ok(pool) +} +``` + +### Wiring into `PgMemoryStore::connect` + +In `crates/vestige-core/src/storage/postgres/mod.rs`, replace the +`todo!()` body left by `0002a` for `connect` and `from_pool` with: + +```rust +// In crates/vestige-core/src/storage/postgres/mod.rs + +use sqlx::PgPool; + +use crate::config::PostgresConfig; +use crate::storage::memory_store::{MemoryStoreError, MemoryStoreResult}; + +mod pool; +mod registry; // see "Registry stub" section below + +pub struct PgMemoryStore { + pool: PgPool, +} + +impl PgMemoryStore { + /// Convenience constructor matching `SqliteMemoryStore::new` shape. + /// Takes a URL + pool size for the common case. + pub async fn connect(url: &str, max_connections: u32) -> MemoryStoreResult { + let cfg = PostgresConfig { + url: url.to_string(), + max_connections: Some(max_connections), + acquire_timeout_secs: None, + }; + Self::connect_with(&cfg).await + } + + /// Full-config constructor. + pub async fn connect_with(cfg: &PostgresConfig) -> MemoryStoreResult { + let pool = pool::build_pool(cfg).await?; + Self::from_pool(pool).await + } + + /// Construct from an already-built pool (used by tests and the migrate + /// CLI to share a pool across operations). + pub async fn from_pool(pool: PgPool) -> MemoryStoreResult { + // Migrations are added by 0002c. + // todo!("run sqlx::migrate! once 0002c lands") + registry::ensure_registry_stub(&pool).await?; + Ok(Self { pool }) + } +} +``` + +`connect_with` is the long-lived API; `connect` becomes a thin shim that +stays compatible with the master-plan-mandated signature. + +### Registry stub + +**File**: `crates/vestige-core/src/storage/postgres/registry.rs` (new, stub). + +```rust +#![cfg(feature = "postgres-backend")] + +//! Embedding registry. Real body lands in sub-plan 0002d. + +use sqlx::PgPool; + +use crate::storage::memory_store::MemoryStoreResult; + +/// Placeholder. Real implementation in 0002d reads/writes `embedding_model` +/// and stamps `ALTER TABLE memories ALTER COLUMN embedding TYPE vector($N)`. +pub(crate) async fn ensure_registry_stub(_pool: &PgPool) -> MemoryStoreResult<()> { + // Intentionally a no-op until 0002c lands the table + 0002d lands the + // real body. Leaving this as todo!() would crash the MCP server at + // startup the moment a user switches `backend = "postgres"`, which is + // not what we want for the build verification step in this sub-plan. + Ok(()) +} +``` + +The no-op keeps `cargo build --features postgres-backend` not just +compiling but also allowing the MCP server to *boot* against a Postgres +URL pointing at an already-migrated database (the local-dev-postgres-setup +docs cover bringing up such a DB by hand). Real init lands in `0002d`. + +--- + +## Error variants + +**File**: `crates/vestige-core/src/storage/memory_store.rs` (edit). + +The Phase 1 enum `MemoryStoreError` gains two feature-gated variants. These +were deferred in `0002a` and become required as soon as `pool.rs` calls +`.map_err(MemoryStoreError::from)` on `sqlx::Error`. + +```rust +// Within enum MemoryStoreError { ... } in memory_store.rs + +#[cfg(feature = "postgres-backend")] +#[error("postgres error: {0}")] +Postgres(#[from] sqlx::Error), + +#[cfg(feature = "postgres-backend")] +#[error("postgres migration error: {0}")] +Migrate(#[from] sqlx::migrate::MigrateError), +``` + +Both use thiserror's `#[from]` attribute so the `?` operator works in +`pool.rs`, the migrate module (`0002c`), and registry code (`0002d`). +Default-features build (no `postgres-backend`) sees neither variant; the +enum stays exhaustive on stable. + +If clippy fires on `non_exhaustive` due to the gated variants, add +`#[non_exhaustive]` on the enum. That has no caller-side effect since the +enum is constructed only inside the crate. + +--- + +## vestige-mcp wiring + +### Cargo feature passthrough + +**File**: `crates/vestige-mcp/Cargo.toml` (edit). + +Add a feature that forwards through to `vestige-core`. Default features in +`vestige-mcp` stay unchanged. + +```toml +[features] +default = ["embeddings", "vector-search"] +embeddings = ["vestige-core/embeddings"] +vector-search = ["vestige-core/vector-search"] +postgres-backend = ["vestige-core/postgres-backend"] +``` + +Verify with: + +```bash +cargo build -p vestige-mcp --features postgres-backend +``` + +### Backend dispatch at startup + +**File**: `crates/vestige-mcp/src/main.rs` (edit around the existing +`Storage::new(storage_path)` call -- see audit note above; in the current +worktree this is around line 285). + +The current code is roughly: + +```rust +let storage_path = match prepare_storage_path(config.data_dir) { ... }; +let storage = match Storage::new(storage_path) { ... }; +``` + +Replace that with a dispatch driven by `VestigeConfig`: + +```rust +use std::sync::Arc; + +use vestige_core::config::{StorageConfig, VestigeConfig}; +use vestige_core::storage::SqliteMemoryStore; +#[cfg(feature = "postgres-backend")] +use vestige_core::storage::postgres::PgMemoryStore; +use vestige_core::storage::MemoryStore; + +// Earlier: still call prepare_storage_path to honour --data-dir override. +let storage_path = match prepare_storage_path(config.data_dir.clone()) { ... }; + +// New: load vestige.toml (or fall back to defaults). +let vestige_cfg = match VestigeConfig::load(config.config_path.as_deref()) { + Ok(c) => c, + Err(e) => { + eprintln!("vestige: failed to load config: {e}"); + std::process::exit(2); + } +}; + +let storage: Arc = match &vestige_cfg.storage { + StorageConfig::Sqlite(sqlite_cfg) => { + // CLI flag --data-dir wins over the config file path. + let path = storage_path.clone().or_else(|| sqlite_cfg.path.clone()); + let s = SqliteMemoryStore::new(path).unwrap_or_else(|e| { + eprintln!("vestige: sqlite init failed: {e}"); + std::process::exit(3); + }); + Arc::new(s) + } + #[cfg(feature = "postgres-backend")] + StorageConfig::Postgres(pg_cfg) => { + let s = PgMemoryStore::connect_with(pg_cfg).await.unwrap_or_else(|e| { + eprintln!("vestige: postgres init failed: {e}"); + std::process::exit(3); + }); + Arc::new(s) + } +}; +``` + +The `config_path: Option` field on the local `Config` (or +clap-derived `Args`) struct must be added if not present; it accepts +`--config `. Default behaviour (no flag) goes through +`VestigeConfig::default_path()`. + +If the existing main wires `Storage` through a concrete type rather than +`Arc`, the dispatch above lives behind a helper: + +```rust +async fn build_store(cfg: &VestigeConfig, cli_path: Option) + -> Result, anyhow::Error> +{ ... } +``` + +and the caller chains `.into()` as needed. Phase 1 already moved +cognitive modules to `Arc` so this should be a pure +substitution; if a concrete-type holdout is found, fix it locally in this +sub-plan (separate commit) rather than punting. + +--- + +## vestige.toml example + +The canonical example to ship in `docs/` (Phase 2 docs land in `0002i`, +runbook), shown here for reference and used verbatim by the unit test +below. + +```toml +# vestige.toml -- top-level configuration +# +# Default location: ~/.vestige/vestige.toml +# Override: vestige-mcp --config /path/to/vestige.toml + +[embeddings] +provider = "fastembed" +model = "nomic-ai/nomic-embed-text-v1.5" + +# --- SQLite backend (default) --- +[storage] +backend = "sqlite" + +[storage.sqlite] +path = "/home/user/.vestige/vestige.db" + +# --- Postgres backend (requires --features postgres-backend) --- +# [storage] +# backend = "postgres" +# +# [storage.postgres] +# url = "postgres://vestige:secret@localhost:5432/vestige" +# max_connections = 10 +# acquire_timeout_secs = 30 + +[server] +# Reserved for Phase 3 (bind address, ports, TLS). + +[auth] +# Reserved for Phase 3 (API keys, claims). +``` + +--- + +## Verification + +Run all of these from the repo root. The first three are the gates that +must pass before this sub-plan is considered done. + +### 1. Default build (no Postgres) + +```bash +cargo build -p vestige-core +cargo build -p vestige-mcp +cargo test -p vestige-core --lib +``` + +Expected: clean build. `VestigeConfig::default()` selects SQLite; the MCP +server boots the same way it did pre-sub-plan. + +### 2. Postgres-feature build + +```bash +cargo build -p vestige-core --features postgres-backend +cargo build -p vestige-mcp --features postgres-backend +``` + +Expected: clean build. `PgMemoryStore::connect_with` resolves to +`pool::build_pool` + `registry::ensure_registry_stub`; no `todo!()` is +reachable on the build path. `connect` and `from_pool` are exported. + +### 3. Clippy across both feature sets + +```bash +cargo clippy -p vestige-core -- -D warnings +cargo clippy -p vestige-core --features postgres-backend -- -D warnings +cargo clippy -p vestige-mcp --features postgres-backend -- -D warnings +``` + +### 4. Unit test: round-trip the example + +Add this test to `crates/vestige-core/src/config.rs`: + +```rust +#[cfg(test)] +mod tests { + use super::*; + + const EXAMPLE_SQLITE: &str = r#" +[embeddings] +provider = "fastembed" +model = "nomic-ai/nomic-embed-text-v1.5" + +[storage] +backend = "sqlite" + +[storage.sqlite] +path = "/home/user/.vestige/vestige.db" +"#; + + #[cfg(feature = "postgres-backend")] + const EXAMPLE_POSTGRES: &str = r#" +[embeddings] +provider = "fastembed" +model = "nomic-ai/nomic-embed-text-v1.5" + +[storage] +backend = "postgres" + +[storage.postgres] +url = "postgres://vestige:secret@localhost:5432/vestige" +max_connections = 10 +acquire_timeout_secs = 30 +"#; + + #[test] + fn parses_sqlite_example() { + let cfg: VestigeConfig = toml::from_str(EXAMPLE_SQLITE).expect("parse"); + match cfg.storage { + StorageConfig::Sqlite(s) => assert!(s.path.is_some()), + #[cfg(feature = "postgres-backend")] + StorageConfig::Postgres(_) => panic!("wrong variant"), + } + assert_eq!(cfg.embeddings.provider, "fastembed"); + } + + #[cfg(feature = "postgres-backend")] + #[test] + fn parses_postgres_example() { + let cfg: VestigeConfig = toml::from_str(EXAMPLE_POSTGRES).expect("parse"); + match cfg.storage { + StorageConfig::Postgres(p) => { + assert_eq!(p.url, "postgres://vestige:secret@localhost:5432/vestige"); + assert_eq!(p.max_connections, Some(10)); + assert_eq!(p.acquire_timeout_secs, Some(30)); + } + StorageConfig::Sqlite(_) => panic!("wrong variant"), + } + } + + #[cfg(not(feature = "postgres-backend"))] + #[test] + fn rejects_postgres_when_feature_off() { + let toml_text = r#" +[storage] +backend = "postgres" + +[storage.postgres] +url = "postgres://x/y" +"#; + let res: Result = toml::from_str(toml_text); + assert!(res.is_err(), "must fail without postgres-backend feature"); + } + + #[test] + fn defaults_pick_sqlite() { + let cfg = VestigeConfig::default(); + assert!(matches!(cfg.storage, StorageConfig::Sqlite(_))); + } + + #[test] + fn load_missing_file_returns_default() { + let tmp = std::env::temp_dir().join("vestige-no-such-file.toml"); + let _ = std::fs::remove_file(&tmp); + let cfg = VestigeConfig::load(Some(&tmp)).expect("missing file is OK"); + assert!(matches!(cfg.storage, StorageConfig::Sqlite(_))); + } + + #[test] + fn load_roundtrip_from_disk() { + let tmp = std::env::temp_dir().join("vestige-roundtrip.toml"); + std::fs::write(&tmp, EXAMPLE_SQLITE).unwrap(); + let cfg = VestigeConfig::load(Some(&tmp)).expect("load"); + assert!(matches!(cfg.storage, StorageConfig::Sqlite(_))); + let _ = std::fs::remove_file(&tmp); + } +} +``` + +Run: + +```bash +cargo test -p vestige-core --lib config:: +cargo test -p vestige-core --lib config:: --features postgres-backend +``` + +### 5. Smoke: server boots with default config + +```bash +# default build, no vestige.toml on disk +cargo run -p vestige-mcp -- --help +# should print help, no panic +``` + +--- + +## Acceptance criteria + +- [ ] `cargo build -p vestige-core` (default features) succeeds. +- [ ] `cargo build -p vestige-core --features postgres-backend` succeeds. +- [ ] `cargo build -p vestige-mcp` (default features) succeeds. +- [ ] `cargo build -p vestige-mcp --features postgres-backend` succeeds. +- [ ] `cargo clippy` with and without `postgres-backend` is clean on both + crates. +- [ ] `crates/vestige-core/src/config.rs` exists, exposes + `VestigeConfig`, `StorageConfig`, `SqliteConfig`, `EmbeddingsConfig`, + `ConfigError`, plus `PostgresConfig` when the feature is on. +- [ ] `VestigeConfig::load(None)` returns `Ok(default)` when + `~/.vestige/vestige.toml` is missing. +- [ ] `VestigeConfig::load(Some(&path))` round-trips both the SQLite and + Postgres example blocks above. +- [ ] With `postgres-backend` off, parsing `backend = "postgres"` returns + a clear `ConfigError::Invalid` mentioning the feature flag, NOT a + panic. +- [ ] `crates/vestige-core/src/storage/postgres/pool.rs` exists, + implementing `build_pool(&PostgresConfig) -> MemoryStoreResult` + with the documented defaults. +- [ ] `PgMemoryStore::connect`, `connect_with`, and `from_pool` all wire + through `pool::build_pool`. None of them is `todo!()`. The registry + step is a no-op stub documented as filled in by `0002d`. +- [ ] `MemoryStoreError::Postgres(sqlx::Error)` and + `MemoryStoreError::Migrate(sqlx::migrate::MigrateError)` exist + behind `#[cfg(feature = "postgres-backend")]` with `#[from]`. +- [ ] `vestige-mcp` has a `postgres-backend` feature that forwards to + `vestige-core/postgres-backend`. +- [ ] `vestige-mcp/src/main.rs` selects SQLite vs Postgres at startup + based on `VestigeConfig`. SQLite is the default when no config file + is present. +- [ ] Unit tests in the "Verification" section pass on both feature sets. + +--- + +## Out of scope (handled by other sub-plans) + +- Migrations (`crates/vestige-core/migrations/postgres/*.sql`) -- `0002c`. +- Real `PgMemoryStore` CRUD/search/scheduling/edges bodies -- `0002d`, + `0002e`. +- `ensure_registry` real body with `ALTER COLUMN TYPE vector(N)` -- `0002d`. +- `vestige migrate --from sqlite --to postgres` CLI -- `0002f`. +- Re-embed flow -- `0002g`. +- Env-var override (`VESTIGE_POSTGRES_URL`, etc.) -- Phase 3. +- RLS, multi-tenant column population -- Phase 3. diff --git a/docs/plans/0002c-migrations.md b/docs/plans/0002c-migrations.md new file mode 100644 index 0000000..ef8e35c --- /dev/null +++ b/docs/plans/0002c-migrations.md @@ -0,0 +1,1119 @@ +# Phase 2 Sub-plan 0002c: sqlx Migrations + +**Status**: Draft +**Depends on**: `0002a-skeleton-and-feature-gate.md` (PgMemoryStore skeleton, error variants), `0002b-pool-and-config.md` (PgPool builder, PostgresConfig) +**Related**: docs/adr/0002-phase-2-execution.md (D7 multi-tenancy reservation, D8 codebase column), docs/plans/0002-phase-2-postgres-backend.md (D4 master SQL), docs/plans/local-dev-postgres-setup.md (local cluster + role + DB) + +--- + +## Context + +This sub-plan covers Phase 2 deliverable D4 (sqlx migration files under +`crates/vestige-core/migrations/postgres/`) PLUS the schema additions decided +in ADR 0002: + +- D7 -- multi-tenancy reservation: `users`, `groups`, `group_memberships` + tables, plus `owner_user_id`, `visibility`, `shared_with_groups` columns on + `knowledge_nodes`. Phase 3 fills these in; Phase 2 just reserves them so the auth + filter is later additive instead of an online migration over a populated, + HNSW-indexed table. +- D8 -- `codebase` promoted to a first-class indexed column on `knowledge_nodes`. + +This sub-plan also adds the parity SQLite migration (V15) that mirrors D7 + +D8 on the SQLite side, so a single-user SQLite deployment sees the same +columns (with stand-in defaults). + +After this sub-plan lands: + +- A fresh Postgres database, with the `vestige` role from the local-dev + setup, can be initialized by running `sqlx::migrate!` against + `crates/vestige-core/migrations/postgres/`, plus one programmatic + `register_model` call before the HNSW migration. +- A fresh SQLite database initialized by `apply_migrations` lands at + schema_version = 15 with the new tables and columns present. +- `PgMemoryStore::connect` wires the migrator into the connect path + (pool build -> migrator up-to v1 -> register_model -> migrator up-to v2). +- The SQLite test suite continues to pass. +- No `sqlx::query!` calls are introduced yet; the offline `.sqlx/` cache is + filled out in `0002d-store-impl-bodies.md`. + +The deliverable is purely schema. No query bodies, no row-mapping, no search. + +--- + +## Postgres migration files + +Layout, relative to repo root: + +``` +crates/vestige-core/migrations/postgres/ + 0001_init.up.sql + 0001_init.down.sql + 0002_hnsw.up.sql + 0002_hnsw.down.sql +``` + +The `migrations/postgres/` directory is sibling-of-`src/`, not under `src/`, +because `sqlx::migrate!` and `sqlx-cli` both look for a path relative to +`CARGO_MANIFEST_DIR`. The directory is committed. + +### 0001_init.up.sql + +Creates extensions, the multi-tenancy tables (D7), the embedding registry, +the domains catalogue, the `knowledge_nodes` table (with D7 + D8 columns merged in), +the FSRS scheduling and edges tables, the review-events log, all non-vector +indexes, the updated_at trigger, and the bootstrap `local` user row. + +The HNSW vector index is deliberately NOT here -- it requires a typmod on +`knowledge_nodes.embedding`, which is stamped by `register_model` at runtime. See +the "HNSW typmod ordering" section below. + +```sql +-- crates/vestige-core/migrations/postgres/0001_init.up.sql +-- +-- Phase 2 initial schema for the Postgres backend. +-- Includes D7 multi-tenancy reservation (users/groups/group_memberships, +-- owner_user_id/visibility/shared_with_groups on knowledge_nodes) and D8 +-- (codebase first-class column on knowledge_nodes). +-- +-- The HNSW index on knowledge_nodes.embedding lives in 0002_hnsw.up.sql; it +-- requires the column typmod to be stamped first by register_model(). + +-- Extensions ---------------------------------------------------------------- + +CREATE EXTENSION IF NOT EXISTS pgcrypto; +CREATE EXTENSION IF NOT EXISTS vector; + +-- Embedding model registry -------------------------------------------------- +-- Mirrors the SQLite table created in Phase 1 V14. +-- One logical row enforced by CHECK (id = 1). + +CREATE TABLE embedding_model ( + id SMALLINT PRIMARY KEY DEFAULT 1 CHECK (id = 1), + name TEXT NOT NULL, + dimension INTEGER NOT NULL CHECK (dimension > 0), + hash TEXT NOT NULL, + created_at TIMESTAMPTZ NOT NULL DEFAULT now() +); + +-- Domains catalogue --------------------------------------------------------- +-- Populated by the Phase 4 DomainClassifier. Phase 2 creates the empty +-- table so list/get/upsert/delete work uniformly against both backends. + +CREATE TABLE domains ( + id TEXT PRIMARY KEY, + label TEXT NOT NULL, + centroid vector, + top_terms TEXT[] NOT NULL DEFAULT '{}', + memory_count INTEGER NOT NULL DEFAULT 0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb +); + +-- Multi-tenancy (D7) -------------------------------------------------------- +-- Reserved in Phase 2; populated in Phase 3. +-- Single bootstrap user inserted at the bottom of this file. + +CREATE TABLE users ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + handle TEXT NOT NULL UNIQUE, + display_name TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb +); + +CREATE TABLE groups ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + handle TEXT NOT NULL UNIQUE, + display_name TEXT, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + metadata JSONB NOT NULL DEFAULT '{}'::jsonb +); + +CREATE TABLE group_memberships ( + user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE, + group_id UUID NOT NULL REFERENCES groups(id) ON DELETE CASCADE, + role TEXT NOT NULL DEFAULT 'member', + joined_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (user_id, group_id), + CHECK (role IN ('member', 'admin')) +); + +-- Core knowledge_nodes table ------------------------------------------------- +-- Original Phase 2 columns merged with D7 (owner_user_id, visibility, +-- shared_with_groups) and D8 (codebase). + +CREATE TABLE knowledge_nodes ( + id UUID PRIMARY KEY DEFAULT gen_random_uuid(), + + -- Content + content TEXT NOT NULL, + node_type TEXT NOT NULL DEFAULT 'general', + tags TEXT[] NOT NULL DEFAULT '{}', + metadata JSONB NOT NULL DEFAULT '{}'::jsonb, + + -- Phase 4 emergent domains (Phase 2 leaves empty) + domains TEXT[] NOT NULL DEFAULT '{}', + domain_scores JSONB NOT NULL DEFAULT '{}'::jsonb, + + -- Embedding (typmod stamped by register_model before 0002_hnsw runs) + embedding vector, + + -- D8: first-class codebase column for high-frequency scoped queries + codebase TEXT, + + -- D7: multi-tenancy reservation. Defaults make Phase 2 single-user + -- behaviour identical to Phase 1. + owner_user_id UUID NOT NULL DEFAULT '00000000-0000-0000-0000-000000000001' + REFERENCES users(id), + visibility TEXT NOT NULL DEFAULT 'private', + shared_with_groups UUID[] NOT NULL DEFAULT '{}', + + -- Timestamps + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), + + -- Generated full-text search vector. Phase 2 uses websearch_to_tsquery + -- against this column at query time (see 0002e-hybrid-search.md). + search_vec TSVECTOR GENERATED ALWAYS AS ( + setweight(to_tsvector('english', coalesce(content, '')), 'A') || + setweight(to_tsvector('english', coalesce(node_type, '')), 'B') || + setweight(to_tsvector('english', coalesce(array_to_string(tags, ' '), '')), 'C') + ) STORED, + + -- Visibility tri-state CHECK constraint. See "Visibility CHECK + -- constraint" section below for the cardinality variant we + -- intentionally do NOT add yet. + CHECK (visibility IN ('private', 'group', 'public')) +); + +-- FSRS scheduling state (1:1 with knowledge_nodes) --------------------------- +-- +-- Note: the FK column is named `memory_id` (not `node_id`) to match the +-- Phase 1 SQLite trait surface: `SchedulingState { memory_id: Uuid, ... }` +-- and `get_scheduling(memory_id: Uuid)` / `update_scheduling(&state)`. The +-- table is `knowledge_nodes` but the Rust identifier remained `memory_id` +-- across Phase 1 and is preserved here so both backends speak the same +-- language at the trait boundary. + +CREATE TABLE scheduling ( + memory_id UUID PRIMARY KEY REFERENCES knowledge_nodes(id) ON DELETE CASCADE, + stability DOUBLE PRECISION NOT NULL DEFAULT 0.0, + difficulty DOUBLE PRECISION NOT NULL DEFAULT 0.0, + retrievability DOUBLE PRECISION NOT NULL DEFAULT 1.0, + last_review TIMESTAMPTZ, + next_review TIMESTAMPTZ, + reps INTEGER NOT NULL DEFAULT 0, + lapses INTEGER NOT NULL DEFAULT 0 +); + +-- Spreading activation graph edges ------------------------------------------ + +CREATE TABLE edges ( + source_id UUID NOT NULL REFERENCES knowledge_nodes(id) ON DELETE CASCADE, + target_id UUID NOT NULL REFERENCES knowledge_nodes(id) ON DELETE CASCADE, + edge_type TEXT NOT NULL DEFAULT 'related', + weight DOUBLE PRECISION NOT NULL DEFAULT 1.0, + created_at TIMESTAMPTZ NOT NULL DEFAULT now(), + PRIMARY KEY (source_id, target_id, edge_type) +); + +-- FSRS review event log (append-only; Phase 5 federation reads) ------------- + +CREATE TABLE review_events ( + id BIGSERIAL PRIMARY KEY, + memory_id UUID NOT NULL REFERENCES knowledge_nodes(id) ON DELETE CASCADE, + timestamp TIMESTAMPTZ NOT NULL DEFAULT now(), + rating SMALLINT NOT NULL, + prior_state JSONB NOT NULL, + new_state JSONB NOT NULL +); + +-- Indexes ------------------------------------------------------------------- + +-- knowledge_nodes: full-text, arrays, hot scalar columns, D7+D8 access patterns +CREATE INDEX idx_knowledge_nodes_fts ON knowledge_nodes USING GIN (search_vec); +CREATE INDEX idx_knowledge_nodes_domains ON knowledge_nodes USING GIN (domains); +CREATE INDEX idx_knowledge_nodes_tags ON knowledge_nodes USING GIN (tags); +CREATE INDEX idx_knowledge_nodes_node_type ON knowledge_nodes (node_type); +CREATE INDEX idx_knowledge_nodes_created ON knowledge_nodes (created_at); +CREATE INDEX idx_knowledge_nodes_updated ON knowledge_nodes (updated_at); + +-- D7 visibility filter (Phase 3 query: WHERE owner_user_id = $me ...) +CREATE INDEX idx_knowledge_nodes_owner ON knowledge_nodes (owner_user_id); +CREATE INDEX idx_knowledge_nodes_shared_groups ON knowledge_nodes USING GIN (shared_with_groups); + +-- D8 codebase scoping (Phase 4 HDBSCAN per-repo, sharing rules in Phase 4). +-- Partial index keeps the index small in single-user mode where most rows +-- never set a codebase. +CREATE INDEX idx_knowledge_nodes_codebase + ON knowledge_nodes (codebase) + WHERE codebase IS NOT NULL; + +-- scheduling: hot lookup paths for FSRS pickers +CREATE INDEX idx_scheduling_next_review ON scheduling (next_review); +CREATE INDEX idx_scheduling_last_review ON scheduling (last_review); + +-- edges: bidirectional + edge type +CREATE INDEX idx_edges_target ON edges (target_id); +CREATE INDEX idx_edges_source ON edges (source_id); +CREATE INDEX idx_edges_type ON edges (edge_type); + +-- review_events: per-memory and chronological +CREATE INDEX idx_review_events_memory ON review_events (memory_id); +CREATE INDEX idx_review_events_ts ON review_events (timestamp); + +-- users / groups: unique handle indexes are implicit; add nothing extra. +-- group_memberships: primary key (user_id, group_id) is the access path. + +-- updated_at trigger on knowledge_nodes ---------------------------------------- + +CREATE OR REPLACE FUNCTION knowledge_nodes_set_updated_at() RETURNS TRIGGER AS $$ +BEGIN + NEW.updated_at := now(); + RETURN NEW; +END; +$$ LANGUAGE plpgsql; + +CREATE TRIGGER trg_knowledge_nodes_updated_at +BEFORE UPDATE ON knowledge_nodes +FOR EACH ROW EXECUTE FUNCTION knowledge_nodes_set_updated_at(); + +-- Bootstrap rows ------------------------------------------------------------ +-- Single 'local' user matches the default on knowledge_nodes.owner_user_id so +-- single-user Phase 2 inserts never violate the FK. + +INSERT INTO users (id, handle, display_name) + VALUES ('00000000-0000-0000-0000-000000000001', 'local', 'Local User'); +``` + +### 0001_init.down.sql + +Reverse-dependency drop order. Trigger and function first, then indexes, +then tables, then extensions are left alone (extensions are global; we do +not drop them in a `down`). + +```sql +-- crates/vestige-core/migrations/postgres/0001_init.down.sql + +DROP TRIGGER IF EXISTS trg_knowledge_nodes_updated_at ON knowledge_nodes; +DROP FUNCTION IF EXISTS knowledge_nodes_set_updated_at(); + +-- knowledge_nodes indexes +DROP INDEX IF EXISTS idx_knowledge_nodes_codebase; +DROP INDEX IF EXISTS idx_knowledge_nodes_shared_groups; +DROP INDEX IF EXISTS idx_knowledge_nodes_owner; +DROP INDEX IF EXISTS idx_knowledge_nodes_updated; +DROP INDEX IF EXISTS idx_knowledge_nodes_created; +DROP INDEX IF EXISTS idx_knowledge_nodes_node_type; +DROP INDEX IF EXISTS idx_knowledge_nodes_tags; +DROP INDEX IF EXISTS idx_knowledge_nodes_domains; +DROP INDEX IF EXISTS idx_knowledge_nodes_fts; + +-- scheduling indexes +DROP INDEX IF EXISTS idx_scheduling_last_review; +DROP INDEX IF EXISTS idx_scheduling_next_review; + +-- edges indexes +DROP INDEX IF EXISTS idx_edges_type; +DROP INDEX IF EXISTS idx_edges_source; +DROP INDEX IF EXISTS idx_edges_target; + +-- review_events indexes +DROP INDEX IF EXISTS idx_review_events_ts; +DROP INDEX IF EXISTS idx_review_events_memory; + +-- Tables, reverse dependency order +DROP TABLE IF EXISTS review_events; +DROP TABLE IF EXISTS edges; +DROP TABLE IF EXISTS scheduling; +DROP TABLE IF EXISTS knowledge_nodes; +DROP TABLE IF EXISTS group_memberships; +DROP TABLE IF EXISTS groups; +DROP TABLE IF EXISTS users; +DROP TABLE IF EXISTS domains; +DROP TABLE IF EXISTS embedding_model; + +-- Extensions are intentionally NOT dropped. They may be in use by other +-- databases on the cluster; dropping them is an admin choice. +``` + +### 0002_hnsw.up.sql + +Single statement; separated from 0001 so reembed (sub-plan 0002g) can +DROP/CREATE this index in isolation without touching anything else. + +```sql +-- crates/vestige-core/migrations/postgres/0002_hnsw.up.sql +-- +-- HNSW index on knowledge_nodes.embedding. This migration runs AFTER +-- register_model() has stamped the typmod via: +-- +-- ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector($N) +-- +-- where $N is the embedder's dimension(). Without the typmod, pgvector +-- rejects HNSW creation with: +-- +-- ERROR: column does not have dimensions +-- +-- See "HNSW typmod ordering" in 0002c-migrations.md and the connect() +-- sequence in 0002a-skeleton-and-feature-gate.md / 0002d-store-impl-bodies.md. +-- +-- Operator class: vector_cosine_ops -> distance operator `<=>`. +-- Build parameters: m = 16, ef_construction = 64 (pgvector defaults; see +-- the master plan 0002 D5 RRF discussion for the rationale). + +CREATE INDEX idx_knowledge_nodes_embedding_hnsw + ON knowledge_nodes USING hnsw (embedding vector_cosine_ops) + WITH (m = 16, ef_construction = 64); +``` + +### 0002_hnsw.down.sql + +```sql +-- crates/vestige-core/migrations/postgres/0002_hnsw.down.sql + +DROP INDEX IF EXISTS idx_knowledge_nodes_embedding_hnsw; +``` + +--- + +## HNSW typmod ordering + +pgvector's HNSW index requires the indexed column to have a typmod (fixed +dimension). `vector` (unconstrained) is rejected; `vector(768)` is accepted. +We cannot bake the dimension into 0001 because the dimension is an +embedder-determined runtime value -- different builds may use different +embedders. + +This forces an ordering: + +1. Apply migration 0001 (creates `knowledge_nodes.embedding vector`, no typmod). +2. Connect, decide which embedder is in use, run + `ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector($N)` + inside `register_model`. +3. Apply migration 0002 (creates HNSW; succeeds because the column now has + a typmod). + +`sqlx::migrate!("...")` runs ALL pending migrations in a single call. It is +not designed to pause between two specific migrations so application code +can interleave a runtime DDL step. So we have two options: + +**Option A: Migration 0002 lives outside the sqlx migrations directory.** +Keep `0001_init.{up,down}.sql` only in `migrations/postgres/`; promote +`0002_hnsw.up.sql` to a Rust `include_str!` constant or a separate +`migrations/postgres-hnsw/` directory, run it manually by `PgMemoryStore` +after `register_model`. + +Pros: simple control flow, one `sqlx::migrate!()` call. +Cons: `sqlx_migrations` table does not record 0002, so `sqlx-cli migrate +info` lies. The HNSW index becomes "shadow" schema state from sqlx's POV. +Reembed (sub-plan 0002g) has to also know about this file outside the +normal migrations directory. + +**Option B (chosen): Both migrations live in the directory; the runner +splits them programmatically.** Use `sqlx::migrate::Migrator::new` to load +the directory and call its `run_to(...)` method with a specific version. + +```rust +// crates/vestige-core/src/storage/postgres/migrations.rs +use sqlx::migrate::Migrator; +use sqlx::PgPool; + +use crate::storage::error::MemoryStoreResult; + +/// Embedded migrator. Loaded at compile time from the migrations directory +/// alongside the crate. Path is relative to CARGO_MANIFEST_DIR. +static MIGRATOR: Migrator = sqlx::migrate!("./migrations/postgres"); + +/// Run migrations up to (and including) version 1. +/// +/// This must be called BEFORE register_model so the schema (knowledge_nodes table, +/// embedding_model registry, etc.) exists for register_model to write into +/// and to ALTER. +pub(crate) async fn run_pre_register(pool: &PgPool) -> MemoryStoreResult<()> { + MIGRATOR.run_to(pool, 1).await?; + Ok(()) +} + +/// Run any remaining migrations (currently: HNSW = version 2). +/// +/// Called AFTER register_model has stamped the embedding column's typmod. +pub(crate) async fn run_post_register(pool: &PgPool) -> MemoryStoreResult<()> { + MIGRATOR.run(pool).await?; + Ok(()) +} +``` + +Pros: sqlx is the only source of truth for migration version state; +`sqlx-cli migrate info` is accurate; reembed re-applies 0002 by name; future +migrations slot in normally. +Cons: relies on `Migrator::run_to`, which exists in sqlx 0.7+ and is the +documented API for staged migration. If that API ever disappears we fall +back to Option A. + +Decision: Option B. `Migrator::run_to(target_version)` is stable in sqlx +0.8. Sub-plan 0002a's `MemoryStoreError` already gains +`#[from] sqlx::migrate::MigrateError` to absorb whichever error variant +this surfaces. + +The `connect()` sequence in sub-plan 0002d will therefore look like: + +```rust +// Sketch only; full body lives in 0002d-store-impl-bodies.md. +pub async fn connect(url: &str, max_connections: u32) -> MemoryStoreResult { + let pool = crate::storage::postgres::pool::build(url, max_connections).await?; + crate::storage::postgres::migrations::run_pre_register(&pool).await?; + let store = Self { pool }; + // register_model is called by the cognitive engine bootstrap, NOT here. + // After it runs, the engine calls store.finalize_schema() which calls + // run_post_register. Same shape as SqliteMemoryStore. + Ok(store) +} + +pub async fn finalize_schema(&self) -> MemoryStoreResult<()> { + crate::storage::postgres::migrations::run_post_register(&self.pool).await +} +``` + +`finalize_schema` lands in 0002d; this sub-plan only ships `run_pre_register` +and `run_post_register` plus their wiring into `connect`. + +--- + +## SQLite V15 migration + +The Phase 1 SQLite schema lives in `crates/vestige-core/src/storage/migrations.rs` +as a `MIGRATIONS` slice. V14 is the latest entry. V15 is appended to mirror +D7 (multi-tenancy) and D8 (codebase) on the SQLite side, so a single-user +SQLite deployment sees the same surface area. + +Constraints versus the Postgres migration: + +- No `UUID[]` -- `shared_with_groups` is a TEXT JSON-encoded `'[]'`. +- No `gen_random_uuid()` -- the bootstrap user UUID is a literal. +- No partial indexes for our chosen pattern (SQLite *does* support partial + indexes since 3.8; we use one for `codebase` to match Postgres). +- No `ADD COLUMN IF NOT EXISTS` -- the V15 column additions are split into a + `MIGRATION_V15_ALTER_COLUMNS` slice exactly like V14 did, so the migration + is idempotent on replay. + +### Insertion point in migrations.rs + +Add to the `MIGRATIONS` slice immediately after V14: + +```rust +// In MIGRATIONS slice, after the V14 entry: +Migration { + version: 15, + description: "ADR 0002 D7+D8: multi-tenancy reservation + codebase column", + up: MIGRATION_V15_UP, +}, +``` + +### V15 SQL + +```rust +/// V15: ADR 0002 D7 + D8. +/// +/// D7 reserves users / groups / group_memberships and owner_user_id / +/// visibility / shared_with_groups columns on knowledge_nodes. Single-user +/// SQLite mode never reads these (the trait surface ignores visibility +/// because there is exactly one user) but they exist so Phase 3 does not +/// have to ALTER a populated table. +/// +/// D8 adds a first-class `codebase` column. +/// +/// Like V14, the ALTER TABLE statements are split into +/// MIGRATION_V15_ALTER_COLUMNS because SQLite has no ADD COLUMN IF NOT EXISTS. +const MIGRATION_V15_UP: &str = r#" +-- Migration V15: multi-tenancy reservation + codebase column. + +-- 1. Users / groups / group_memberships ----------------------------------- +-- Mirrors the Postgres D7 tables. Single bootstrap user inserted below. + +CREATE TABLE IF NOT EXISTS users ( + id TEXT PRIMARY KEY, + handle TEXT NOT NULL UNIQUE, + display_name TEXT, + created_at TEXT NOT NULL, + metadata TEXT NOT NULL DEFAULT '{}' +); + +CREATE TABLE IF NOT EXISTS groups ( + id TEXT PRIMARY KEY, + handle TEXT NOT NULL UNIQUE, + display_name TEXT, + created_at TEXT NOT NULL, + metadata TEXT NOT NULL DEFAULT '{}' +); + +CREATE TABLE IF NOT EXISTS group_memberships ( + user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE, + group_id TEXT NOT NULL REFERENCES groups(id) ON DELETE CASCADE, + role TEXT NOT NULL DEFAULT 'member' CHECK (role IN ('member', 'admin')), + joined_at TEXT NOT NULL, + PRIMARY KEY (user_id, group_id) +); + +-- 2. Bootstrap 'local' user. Same UUID as the Postgres default so a future +-- portable export from SQLite -> import to Postgres preserves owner_user_id. + +INSERT OR IGNORE INTO users (id, handle, display_name, created_at) + VALUES ('00000000-0000-0000-0000-000000000001', 'local', 'Local User', + datetime('now')); + +-- 3. Per-memory column additions are applied separately by the migration +-- runner (see MIGRATION_V15_ALTER_COLUMNS). + +-- 4. Indexes that do not depend on the new columns. Index creation on the +-- new knowledge_nodes columns is done after MIGRATION_V15_ALTER_COLUMNS +-- runs (see runner glue below). + +UPDATE schema_version SET version = 15, applied_at = datetime('now'); +"#; + +/// V15 column additions. SQLite has no ADD COLUMN IF NOT EXISTS, so the +/// runner skips "duplicate column" errors per statement (same shape as V14). +pub const MIGRATION_V15_ALTER_COLUMNS: &[&str] = &[ + // D7 columns. Defaults match the Postgres side. shared_with_groups is + // a JSON-encoded array. + "ALTER TABLE knowledge_nodes ADD COLUMN owner_user_id TEXT NOT NULL DEFAULT '00000000-0000-0000-0000-000000000001'", + "ALTER TABLE knowledge_nodes ADD COLUMN visibility TEXT NOT NULL DEFAULT 'private'", + "ALTER TABLE knowledge_nodes ADD COLUMN shared_with_groups TEXT NOT NULL DEFAULT '[]'", + // D8 column. + "ALTER TABLE knowledge_nodes ADD COLUMN codebase TEXT", +]; + +/// V15 index creation. Runs AFTER the ALTER COLUMN statements succeed. +/// Kept as a separate batch so a partial replay (columns already there, +/// indexes not yet) still creates the indexes. +const MIGRATION_V15_INDEXES: &str = r#" +CREATE INDEX IF NOT EXISTS idx_nodes_owner_user_id ON knowledge_nodes(owner_user_id); +CREATE INDEX IF NOT EXISTS idx_nodes_codebase ON knowledge_nodes(codebase) WHERE codebase IS NOT NULL; +-- shared_with_groups is TEXT JSON in SQLite; we do not add a GIN-equivalent +-- index. Phase 3 lookups on the SQLite side will scan; SQLite never serves +-- the multi-user query path in Phase 2-4 anyway. +"#; +``` + +### Runner glue + +Extend `apply_migrations` in `migrations.rs` to recognise V15 the same way +it recognises V14: + +```rust +// Existing pattern for V14 lives in apply_migrations; extend it: +if migration.version == 15 { + for stmt in MIGRATION_V15_ALTER_COLUMNS { + if let Err(e) = conn.execute_batch(stmt) { + let msg = e.to_string(); + if msg.contains("duplicate column name") { + tracing::debug!( + "V15 ALTER TABLE skipped (column already exists): {}", + msg + ); + } else { + return Err(e); + } + } + } + // Indexes run *after* the columns exist. + conn.execute_batch(MIGRATION_V15_INDEXES)?; +} + +// Then the normal: +conn.execute_batch(migration.up)?; +``` + +Order of operations on a fresh in-memory DB: + +1. V1 - V14 run as before. +2. V15: column ALTERs run first (so MIGRATION_V15_INDEXES sees them). +3. V15 main body creates users/groups/group_memberships and the bootstrap row. +4. V15 indexes batch runs. +5. schema_version advances to 15. + +This intentionally mirrors how V14 handles its ALTER + index pair. + +### Existing-data backfill + +Existing SQLite databases (every Phase 1 deployment) have populated +`knowledge_nodes` rows. The V15 ALTER COLUMN ADD COLUMN statements assign +the default values to every existing row: + +- `owner_user_id` -> `'00000000-0000-0000-0000-000000000001'` +- `visibility` -> `'private'` +- `shared_with_groups` -> `'[]'` +- `codebase` -> NULL + +Phase 2 leaves these defaults in place. Phase 3 owns the migration story +for populating real owner UUIDs and visibility values. + +--- + +## Rust wrapper + +Single file: + +```rust +// crates/vestige-core/src/storage/postgres/migrations.rs +// +// sqlx::migrate! wrapper for the Postgres backend. +// +// We split the migration apply into two halves around register_model: +// - run_pre_register: applies everything up to and including version 1 +// (schema, indexes, bootstrap row). Safe to call on a +// fresh DB. +// - run_post_register: applies the remainder (currently: 0002_hnsw, which +// needs the embedding column typmod stamped first). +// +// See docs/plans/0002c-migrations.md "HNSW typmod ordering" for why this +// split exists. + +#![cfg(feature = "postgres-backend")] + +use sqlx::PgPool; +use sqlx::migrate::Migrator; + +use crate::storage::error::MemoryStoreResult; + +/// Embedded migrator. Path is relative to CARGO_MANIFEST_DIR +/// (`crates/vestige-core/`). +static MIGRATOR: Migrator = sqlx::migrate!("./migrations/postgres"); + +/// Apply migrations through version 1 (the schema-only migration). +/// +/// Idempotent: sqlx::migrate consults the `_sqlx_migrations` table and is +/// a no-op on a database already at version 1 or higher. +pub(crate) async fn run_pre_register(pool: &PgPool) -> MemoryStoreResult<()> { + MIGRATOR.run_to(pool, 1).await?; + Ok(()) +} + +/// Apply any remaining migrations. Called after `register_model` has +/// stamped the typmod on `knowledge_nodes.embedding`. +pub(crate) async fn run_post_register(pool: &PgPool) -> MemoryStoreResult<()> { + MIGRATOR.run(pool).await?; + Ok(()) +} +``` + +Wiring into `PgMemoryStore::connect`. The skeleton from 0002a uses +`todo!()` for everything past pool construction. This sub-plan replaces +that with `run_pre_register` only; `run_post_register` is invoked by +`finalize_schema`, which lands in 0002d. Sketch: + +```rust +// In crates/vestige-core/src/storage/postgres/mod.rs (sub-plan 0002a wires +// pool construction; this sub-plan adds the run_pre_register call): + +impl PgMemoryStore { + pub async fn connect(url: &str, max_connections: u32) -> MemoryStoreResult { + let pool = super::pool::build(url, max_connections).await?; + super::migrations::run_pre_register(&pool).await?; + Ok(Self { pool }) + } +} +``` + +Module wire-up in `crates/vestige-core/src/storage/postgres/mod.rs`: + +```rust +mod migrations; // pub(crate) functions; not re-exported. +``` + +### Error variant + +Sub-plan 0002a already added (under feature gate) to `MemoryStoreError`: + +```rust +#[cfg(feature = "postgres-backend")] +#[error("postgres migration error: {0}")] +Migrate(#[from] sqlx::migrate::MigrateError), +``` + +`run_pre_register` / `run_post_register` use the `?` operator and the +`#[from]` conversion handles it; no extra error handling code is needed. + +--- + +## Visibility CHECK constraint + +ADR 0002 D7 specifies the tri-state enum: + +``` +visibility IN ('private', 'group', 'public') +``` + +This sub-plan includes that CHECK on the `knowledge_nodes` table (see 0001_init.up.sql +above) on both sides: + +- Postgres: `CHECK (visibility IN ('private', 'group', 'public'))` inline on + the table. +- SQLite: same CHECK constraint can be added to V15 if desired. (It is not + in the V15 body above because adding a CHECK via ALTER TABLE on SQLite + requires a table rebuild; we trust the application layer for SQLite, since + SQLite never serves the multi-user query path in Phase 2.) + +The stronger consistency rule from the ADR 0002 follow-ups section, + +``` +CHECK ( + visibility = 'private' + OR cardinality(shared_with_groups) > 0 + OR visibility = 'public' +) +``` + +is intentionally NOT added in this sub-plan. Rationale: + +- The rule is a "no orphan group rows" sanity check, not a correctness + requirement for Phase 2 (single-user mode never touches the column). +- Phase 3 is the first phase that writes `visibility = 'group'`. The check + belongs in the Phase 3 migration that lights up auth, alongside the + application code that ensures `shared_with_groups` is populated before + the visibility flips. +- Adding it now and discovering Phase 3 wants a different shape forces an + online CHECK constraint replacement. + +Recommendation: include only the IN check in Phase 2; revisit the +cardinality check in Phase 3. + +--- + +## Offline sqlx cache + +`crates/vestige-core/.sqlx/` is the on-disk cache of compile-time-checked +queries that `sqlx::query!` / `sqlx::query_as!` emit at build time when +`SQLX_OFFLINE=true`. It is committed to the repo so builds without +`DATABASE_URL` (CI, downstream consumers, contributors without Postgres) +succeed. + +This sub-plan does NOT yet generate or commit `.sqlx/` content. Reasons: + +- `sqlx::query!` calls are introduced in `0002d-store-impl-bodies.md` (real + CRUD bodies) and `0002e-hybrid-search.md` (RRF). This sub-plan ships only + the migrations directory and a wrapper that uses `sqlx::migrate!` -- which + is a compile-time macro that reads files, not a query macro that needs a + DB connection. +- Generating an empty `.sqlx/` directory now is noise that gets immediately + overwritten in the next sub-plan. + +Sub-plan 0002d will land the procedure: + +```sh +# Local dev box with vestige DB initialised per local-dev-postgres-setup.md. +export DATABASE_URL="postgresql://vestige:$(cat ~/.vestige_pg_pw)@127.0.0.1:5432/vestige" + +# Apply migrations against the dev DB. +cargo sqlx migrate run \ + --source crates/vestige-core/migrations/postgres \ + --database-url "$DATABASE_URL" + +# Generate the offline cache. +cargo sqlx prepare --workspace -- --features postgres-backend + +# Verify cache compiles offline. +SQLX_OFFLINE=true cargo check --workspace --features postgres-backend +``` + +The `.sqlx/` directory commit policy is: committed, reviewed in PRs that +add or change `query!` calls, regenerated locally and pushed. + +What this sub-plan DOES need from sqlx-cli, for verification only (see next +section): `cargo sqlx migrate run --source crates/vestige-core/migrations/postgres`. + +--- + +## Verification + +Two halves: Postgres migrations run cleanly on a fresh DB; SQLite V15 does +not break the Phase 1 store. + +### Postgres + +Prerequisites: Postgres 18 with pgvector, a role with CREATEDB and EXTENSION +rights, per `docs/plans/local-dev-postgres-setup.md`. Alternatively, a +container: + +```sh +podman run --rm -d --name vestige-pg \ + -e POSTGRES_PASSWORD=devpw \ + -e POSTGRES_USER=vestige \ + -e POSTGRES_DB=vestige \ + -p 5432:5432 \ + docker.io/pgvector/pgvector:pg16 + +export DATABASE_URL="postgresql://vestige:devpw@127.0.0.1:5432/vestige" +``` + +Steps: + +1. Apply migrations. From the repo root: + + ```sh + cargo install sqlx-cli --no-default-features --features postgres + cargo sqlx migrate run \ + --source crates/vestige-core/migrations/postgres \ + --database-url "$DATABASE_URL" + ``` + + Expected output: `Applied 1/migrate init` (`0002` is gated on typmod; + sqlx-cli will run it and pgvector will reject the HNSW creation with + "column does not have dimensions". This is the expected behaviour when + running migrations without going through the Rust connect path. To run + 0002 manually for verification, first stamp the typmod: + + ```sh + psql "$DATABASE_URL" -c "ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector(768);" + cargo sqlx migrate run \ + --source crates/vestige-core/migrations/postgres \ + --database-url "$DATABASE_URL" + ``` + + Now 0002 should apply.) + +2. Verify tables exist: + + ```sh + psql "$DATABASE_URL" -c "\dt" + ``` + + Expected (alphabetical): + ``` + domains + edges + embedding_model + group_memberships + groups + knowledge_nodes + review_events + scheduling + users + ``` + +3. Verify the bootstrap user row: + + ```sh + psql "$DATABASE_URL" -c "SELECT id, handle, display_name FROM users;" + ``` + + Expected: + ``` + id | handle | display_name + --------------------------------------+--------+-------------- + 00000000-0000-0000-0000-000000000001 | local | Local User + ``` + +4. Verify HNSW index (only after the typmod stamp + migrate 0002): + + ```sh + psql "$DATABASE_URL" -c "\d knowledge_nodes" + ``` + + The trailing `Indexes:` block should include `idx_knowledge_nodes_embedding_hnsw`. + +5. Verify the D7+D8 columns are present: + + ```sh + psql "$DATABASE_URL" -c " + SELECT column_name, data_type, column_default + FROM information_schema.columns + WHERE table_name = 'knowledge_nodes' + AND column_name IN ('owner_user_id', 'visibility', + 'shared_with_groups', 'codebase') + ORDER BY column_name; + " + ``` + + Expected: four rows, with `owner_user_id` defaulting to the bootstrap + UUID, `visibility` to `'private'::text`, `shared_with_groups` to + `'{}'::uuid[]`, `codebase` NULL-default. + +6. Verify CHECK constraint: + + ```sh + psql "$DATABASE_URL" -c " + INSERT INTO knowledge_nodes (content, visibility) VALUES ('test', 'bogus'); + " + # Expected: ERROR: new row for relation \"knowledge_nodes\" violates check constraint + ``` + +7. Roll back to verify down migrations work: + + ```sh + cargo sqlx migrate revert \ + --source crates/vestige-core/migrations/postgres \ + --database-url "$DATABASE_URL" + cargo sqlx migrate revert \ + --source crates/vestige-core/migrations/postgres \ + --database-url "$DATABASE_URL" + ``` + + `\dt` should then list only the sqlx-managed `_sqlx_migrations` table. + +8. Rust-side smoke test (no `sqlx::query!` calls yet, so cannot live in + a `#[sqlx::test]`-decorated function until 0002d). Manual: + + ```sh + cargo build -p vestige-core --features postgres-backend + ``` + + Should compile. The `sqlx::migrate!("./migrations/postgres")` macro + reads the directory at compile time; a missing file or syntax error + surfaces as a compile error. + +### SQLite + +1. Run the existing test suite: + + ```sh + cargo test -p vestige-core + ``` + + Expected: 352 (or current count + new V15 tests) tests pass, zero + warnings. + +2. New test in `migrations.rs#tests`: + + ```rust + #[test] + fn test_v15_advances_to_15_and_adds_d7_d8_columns() { + let conn = rusqlite::Connection::open_in_memory().expect("open in-memory"); + apply_migrations(&conn).expect("apply_migrations succeeds"); + + let version = get_current_version(&conn).expect("read schema_version"); + assert_eq!(version, 15, "schema_version should advance to 15"); + + // Tables exist + for tbl in ["users", "groups", "group_memberships"] { + let n: i32 = conn.query_row( + "SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?1", + [tbl], + |r| r.get(0), + ).expect("query sqlite_master"); + assert_eq!(n, 1, "table {tbl} should exist after V15"); + } + + // Bootstrap user row exists + let n: i32 = conn.query_row( + "SELECT COUNT(*) FROM users WHERE id = '00000000-0000-0000-0000-000000000001'", + [], + |r| r.get(0), + ).expect("query users"); + assert_eq!(n, 1, "bootstrap local user row should exist"); + + // D7+D8 columns on knowledge_nodes + let cols: Vec = conn + .prepare("PRAGMA table_info(knowledge_nodes)") + .unwrap() + .query_map([], |r| r.get::<_, String>(1)) + .unwrap() + .collect::>() + .unwrap(); + for c in ["owner_user_id", "visibility", "shared_with_groups", "codebase"] { + assert!(cols.iter().any(|x| x == c), + "knowledge_nodes should have column {c}"); + } + } + ``` + +3. Idempotency: re-applying V15 on an already-V15 DB must not error. + `apply_migrations` already skips when `current_version >= migration.version`; + no extra test needed beyond ensuring the V14 + V15 ALTER pattern works. + +4. Existing-data backfill smoke: insert a row before applying V15, then + verify the defaults populate: + + ```rust + #[test] + fn test_v15_backfills_existing_rows_with_defaults() { + let conn = rusqlite::Connection::open_in_memory().expect("open"); + + // Apply migrations through V14 only. + // (We rely on the fact that re-running apply_migrations is a no-op, + // so we apply all, then probe the columns. The V15 ALTER on a + // populated table is what we are testing implicitly.) + apply_migrations(&conn).expect("V1-V15"); + + // Insert a row using only Phase 1 columns; V15 defaults must + // populate owner_user_id / visibility / shared_with_groups / codebase. + conn.execute( + "INSERT INTO knowledge_nodes (id, content, node_type, created_at, updated_at, last_accessed) + VALUES ('test', 'hello', 'fact', datetime('now'), datetime('now'), datetime('now'))", + [], + ).expect("insert"); + + let (owner, vis, shared, codebase): (String, String, String, Option) = + conn.query_row( + "SELECT owner_user_id, visibility, shared_with_groups, codebase + FROM knowledge_nodes WHERE id = 'test'", + [], + |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?, r.get(3)?)), + ).expect("query"); + + assert_eq!(owner, "00000000-0000-0000-0000-000000000001"); + assert_eq!(vis, "private"); + assert_eq!(shared, "[]"); + assert_eq!(codebase, None); + } + ``` + +5. Live deployment: apply V15 to a copy of `~/.vestige/vestige.db` and + verify the existing 150 memories all carry the four new columns with + default values: + + ```sh + cp ~/.vestige/vestige.db /tmp/v15-test.db + sqlite3 /tmp/v15-test.db <<'SQL' + .schema knowledge_nodes + SELECT COUNT(*) FROM knowledge_nodes; + SELECT DISTINCT owner_user_id, visibility, shared_with_groups + FROM knowledge_nodes LIMIT 5; + SQL + # (Migration applies on first read by the vestige binary running V15.) + ``` + + Capture pre- and post-counts. Expected: no row count change, all new + columns populated by defaults. + +--- + +## Acceptance criteria + +- [ ] `crates/vestige-core/migrations/postgres/` directory contains exactly + four files: `0001_init.up.sql`, `0001_init.down.sql`, + `0002_hnsw.up.sql`, `0002_hnsw.down.sql`. Content matches this + sub-plan. +- [ ] `crates/vestige-core/src/storage/postgres/migrations.rs` exports + `run_pre_register` and `run_post_register` as `pub(crate)` async + functions returning `MemoryStoreResult<()>`. Compiles with + `--features postgres-backend`. +- [ ] `PgMemoryStore::connect` (sub-plan 0002a skeleton) is updated to call + `run_pre_register` immediately after pool construction. `connect` + still returns before `register_model` runs; `run_post_register` + lands in 0002d via `finalize_schema`. +- [ ] `crates/vestige-core/src/storage/migrations.rs` has a new V15 entry + in `MIGRATIONS`, with `MIGRATION_V15_UP`, `MIGRATION_V15_ALTER_COLUMNS`, + and `MIGRATION_V15_INDEXES` constants. `apply_migrations` handles + V15 the same shape as V14. +- [ ] `cargo test -p vestige-core` passes. New tests cover V15 advance, + D7+D8 column existence, bootstrap user row, and existing-row backfill. +- [ ] `cargo build -p vestige-core --features postgres-backend` compiles + (the `sqlx::migrate!` macro will fail at compile time if any of the + four SQL files is missing or malformed). +- [ ] `cargo sqlx migrate run --source crates/vestige-core/migrations/postgres` + against a fresh container applies 0001 cleanly; `\dt` lists the nine + Phase 2 tables; `users` contains the bootstrap row. +- [ ] After the manual typmod stamp documented above, `cargo sqlx migrate + run` applies 0002 and `\d knowledge_nodes` shows `idx_knowledge_nodes_embedding_hnsw`. +- [ ] `cargo sqlx migrate revert` twice cleans the DB back to only the + `_sqlx_migrations` table. +- [ ] Inserting a row with `visibility = 'bogus'` is rejected by the CHECK + constraint. +- [ ] No `sqlx::query!` / `sqlx::query_as!` calls are added in this + sub-plan; the `.sqlx/` offline cache is not yet generated. +- [ ] The existing live SQLite DB on the development machine migrates from + V14 to V15 without row count change, and the 150 existing rows all + receive the four V15 default values. diff --git a/docs/plans/0002d-store-impl-bodies.md b/docs/plans/0002d-store-impl-bodies.md new file mode 100644 index 0000000..ad1d9b7 --- /dev/null +++ b/docs/plans/0002d-store-impl-bodies.md @@ -0,0 +1,1771 @@ +# Phase 2 Sub-Plan 0002d -- Store Implementation Bodies + +**Status**: Ready +**Depends on**: +- `0002a-skeleton-and-feature-gate.md` -- `PgMemoryStore` struct + trait impl block exist with `todo!()` bodies. +- `0002b-pool-and-config.md` -- `PgPool` is constructable, `MemoryStoreError::Postgres` and `MemoryStoreError::Migrate` variants exist behind the `postgres-backend` feature. +- `0002c-migrations.md` -- the two sqlx migrations (`0001_init`, `0002_hnsw`) exist, the schema is applied on `connect`, the `knowledge_nodes` / `scheduling` / `edges` / `domains` / `embedding_model` / `users` / `groups` / `group_memberships` / `review_events` tables exist with the D7+D8 columns. + +This sub-plan replaces every `todo!()` in +`crates/vestige-core/src/storage/postgres/mod.rs` with a real sqlx-backed +body, and adds `crates/vestige-core/src/storage/postgres/registry.rs` with +the `ensure_registry` / `register_model` typmod-stamping logic. + +The hybrid `search()` method is the meatiest single body in the backend +(RRF in one SQL statement) and lives in its own sub-plan +(`0002e-hybrid-search.md`). The bodies for the trivial single-branch +variants `fts_search` and `vector_search` are still inside this sub-plan +because they share row-mapping infrastructure with the CRUD bodies. + +Out of scope for this sub-plan: +- The full hybrid `search()` -- see `0002e-hybrid-search.md`. +- SQLite -> Postgres migrate CLI -- see `0002f-migrate-cli.md`. +- Re-embed flow -- see `0002g-reembed.md`. +- Phase 3 visibility filter -- explicitly NOT wired in Phase 2; see the + "Visibility filter posture" section below. + +--- + +## Context + +The Phase 1 `MemoryStore` trait surface is defined in +`crates/vestige-core/src/storage/memory_store.rs` and is the source of +truth for method signatures. ADR 0002 D7 added owner / visibility / +shared_with_groups columns to the `knowledge_nodes` table; ADR 0002 D8 promoted +`codebase` to a first-class column. The sqlx bodies in this sub-plan must +write to and read from those columns, but per ADR 0002 D7 they must NOT +filter on them in Phase 2 -- the visibility filter is a Phase 3 +deliverable that takes an `AuthContext` parameter. + +The semantics of every body must match the SQLite backend's current +behaviour. Where Postgres has native types (`UUID`, `JSONB`, `vector`, +`TEXT[]`, `TIMESTAMPTZ`) we use them directly; the SQLite backend's +RFC3339-string-and-JSON-blob encoding is an artefact of SQLite typing, +not the trait contract. + +Compile-time SQL validation uses sqlx's `query!` / `query_as!` macros. +The first time these macros run against a real database in CI they +populate `.sqlx/` query metadata; the metadata file is committed so +offline builds (CI without a live Postgres) succeed. + +--- + +## MemoryRecord type changes + +ADR 0002 D7 and D8 added four new columns to the `knowledge_nodes` table. +The `MemoryRecord` struct in +`crates/vestige-core/src/storage/memory_store.rs` must grow matching +fields so the trait surface can carry the data through both backends. +This is an additive change to the public type. + +Add to `MemoryRecord` (after the existing `metadata` field): + +```rust +/// Owner of this memory. Defaults to the local bootstrap user +/// (`00000000-0000-0000-0000-000000000001`) in single-user mode. +pub owner_user_id: Uuid, + +/// Tri-state visibility. ADR 0002 D7. +pub visibility: Visibility, + +/// Group IDs this memory is shared with when `visibility == Group`. +/// Empty for `Private` and `Public`. +pub shared_with_groups: Vec, + +/// First-class codebase tag. ADR 0002 D8. None if the ingest pipeline +/// could not infer one. +pub codebase: Option, +``` + +Add a new enum next to `MemoryRecord`: + +```rust +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +pub enum Visibility { + Private, + Group, + Public, +} + +impl Visibility { + pub fn as_str(&self) -> &'static str { + match self { + Self::Private => "private", + Self::Group => "group", + Self::Public => "public", + } + } + + pub fn from_str(s: &str) -> MemoryStoreResult { + match s { + "private" => Ok(Self::Private), + "group" => Ok(Self::Group), + "public" => Ok(Self::Public), + other => Err(MemoryStoreError::Backend( + format!("unknown visibility value: {other}"), + )), + } + } +} + +impl Default for Visibility { + fn default() -> Self { Self::Private } +} +``` + +`MemoryRecord` already derives `Serialize` and `Deserialize`; the new +fields ride along automatically. Two callers must change as part of this +sub-plan: + +1. **SQLite backend (V15 migration ships in `0001b-sqlite-split.md` or + the same Phase 1 amendment branch)**: the SQLite backend reads the + four new columns out of `knowledge_nodes` (V15 added them) and + populates the new fields in `Self::node_to_record`. Bootstrap user + ID is the same constant on both backends. Existing call sites that + construct `MemoryRecord` literally (in tests, in cognitive modules) + may default-init the four new fields: + + ```rust + MemoryRecord { + // ... existing fields ... + owner_user_id: LOCAL_USER_ID, + visibility: Visibility::default(), + shared_with_groups: Vec::new(), + codebase: None, + metadata: serde_json::json!({}), + } + ``` + + A single `pub const LOCAL_USER_ID: Uuid = uuid::uuid!("00000000-0000-0000-0000-000000000001");` + in `storage::memory_store` provides the bootstrap constant. + +2. **Cognitive modules that build `MemoryRecord` from the ingest + pipeline**: the ingest path already captures `codebase` in metadata + (see ADR 0002 D8). Lift it from `metadata.codebase` to the new + `codebase` field at the boundary where `MemoryRecord` is built. The + `metadata.codebase` JSON key is removed in the same commit; the + column is now the only source of truth. + +The change is purely additive to the trait surface -- no method +signatures change. Backwards compatibility for stored data (in the +SQLite case) comes from V15 defaulting the new columns to `'private'` +and the bootstrap user. The Postgres schema applies the same defaults +in `0001_init.up.sql`. + +--- + +## Registry module + +New file: `crates/vestige-core/src/storage/postgres/registry.rs`. + +```rust +#![cfg(feature = "postgres-backend")] + +//! Embedding-model registry for the Postgres backend. +//! +//! The `embedding_model` table stores exactly one row (id = 1) describing +//! the model whose vectors live in `knowledge_nodes.embedding`. Phase 2 enforces +//! that the active embedder matches the registered model on every write; +//! re-embed (`0002g-reembed.md`) is the only flow allowed to change the +//! row. +//! +//! The pgvector column `knowledge_nodes.embedding` is created in +//! `0001_init.up.sql` with a placeholder type (`vector`) -- no typmod. +//! On first connect we stamp the real dimension via +//! `ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector($N)` so the +//! HNSW index (created in `0002_hnsw.up.sql`) sees a sized type. + +use sqlx::PgPool; + +use crate::storage::memory_store::{ + MemoryStoreError, MemoryStoreResult, ModelSignature, +}; + +/// Look up the registered signature, if any. Returns `Ok(None)` on a +/// fresh database. +pub(crate) async fn fetch_registry( + pool: &PgPool, +) -> MemoryStoreResult> { + let row = sqlx::query!( + r#" + SELECT name, dimension, hash + FROM embedding_model + WHERE id = 1 + "# + ) + .fetch_optional(pool) + .await?; + + Ok(row.map(|r| ModelSignature { + name: r.name, + dimension: r.dimension as usize, + hash: r.hash, + })) +} + +/// First-ever call inserts the row and stamps the typmod on +/// `knowledge_nodes.embedding`. Subsequent calls compare against the stored +/// row and return `ModelMismatch` if any field differs. +pub(crate) async fn ensure_registry( + pool: &PgPool, + sig: &ModelSignature, +) -> MemoryStoreResult<()> { + let existing = fetch_registry(pool).await?; + + match existing { + None => { + sqlx::query!( + r#" + INSERT INTO embedding_model (id, name, dimension, hash) + VALUES (1, $1, $2, $3) + "#, + sig.name, + sig.dimension as i32, + sig.hash, + ) + .execute(pool) + .await?; + + stamp_vector_typmod(pool, sig.dimension).await?; + Ok(()) + } + Some(reg) if reg == *sig => Ok(()), + Some(reg) => Err(MemoryStoreError::ModelMismatch { + registered_name: reg.name, + registered_dim: reg.dimension, + registered_hash: reg.hash, + actual_name: sig.name.clone(), + actual_dim: sig.dimension, + actual_hash: sig.hash.clone(), + }), + } +} + +/// Called only by the re-embed flow (`0002g-reembed.md`) after a full +/// re-encode has rewritten every row. Updates the registry row and +/// re-stamps the typmod for the new dimension. +pub(crate) async fn update_registry_for_reembed( + pool: &PgPool, + sig: &ModelSignature, +) -> MemoryStoreResult<()> { + sqlx::query!( + r#" + UPDATE embedding_model + SET name = $1, dimension = $2, hash = $3, created_at = now() + WHERE id = 1 + "#, + sig.name, + sig.dimension as i32, + sig.hash, + ) + .execute(pool) + .await?; + + stamp_vector_typmod(pool, sig.dimension).await?; + Ok(()) +} + +async fn stamp_vector_typmod(pool: &PgPool, dim: usize) -> MemoryStoreResult<()> { + // pgvector's typmod is part of the column type, not a bound parameter. + // `format!` is safe here because `dim` is a `usize` cast to a decimal + // literal; there is no path for user-controlled SQL to reach this + // string. + let ddl = format!( + "ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector({dim})" + ); + sqlx::query(&ddl).execute(pool).await?; + Ok(()) +} +``` + +Wire the new module into `crates/vestige-core/src/storage/postgres/mod.rs`: + +```rust +pub(crate) mod registry; +``` + +The `fetch_registry` / `ensure_registry` functions are reached from the +trait methods `registered_model` and `register_model` (see method bodies +below). `update_registry_for_reembed` is reached only from +`postgres::reembed`, which is filled in by `0002g-reembed.md`. + +--- + +## Method-by-method bodies + +Every body below replaces a `todo!()` in +`crates/vestige-core/src/storage/postgres/mod.rs`. Method order matches +the trait declaration in `memory_store.rs`. + +Common imports at the top of `mod.rs`: + +```rust +use chrono::{DateTime, Utc}; +use pgvector::Vector; +use uuid::Uuid; + +use crate::storage::memory_store::{ + Domain, HealthStatus, LocalMemoryStore, MemoryEdge, MemoryRecord, + MemoryStoreError, MemoryStoreResult, ModelSignature, SchedulingState, + SearchQuery, SearchResult, StoreStats, Visibility, +}; +``` + +Recurring row-to-record helper (private to `mod.rs`): + +```rust +fn row_to_record( + id: Uuid, + content: String, + node_type: String, + tags: Vec, + domains: Vec, + domain_scores: serde_json::Value, + codebase: Option, + owner_user_id: Uuid, + visibility: String, + shared_with_groups: Vec, + embedding: Option, + metadata: serde_json::Value, + created_at: DateTime, + updated_at: DateTime, +) -> MemoryStoreResult { + let domain_scores: std::collections::HashMap = + serde_json::from_value(domain_scores).unwrap_or_default(); + let embedding = embedding.map(|v| v.to_vec()); + Ok(MemoryRecord { + id, + domains, + domain_scores, + content, + node_type, + tags, + embedding, + created_at, + updated_at, + metadata, + owner_user_id, + visibility: Visibility::from_str(&visibility)?, + shared_with_groups, + codebase, + }) +} +``` + +### Lifecycle + +#### `init` + +```rust +async fn init(&self) -> MemoryStoreResult<()> +``` + +Migrations already ran in `connect`; this is a no-op identical to +SQLite's behaviour. + +```rust +async fn init(&self) -> MemoryStoreResult<()> { + Ok(()) +} +``` + +#### `health_check` + +```rust +async fn health_check(&self) -> MemoryStoreResult +``` + +Issue a trivial `SELECT 1`. Pool acquisition errors degrade to +`HealthStatus::Degraded`; any other error path returns `Unavailable`. + +```rust +async fn health_check(&self) -> MemoryStoreResult { + match sqlx::query_scalar!("SELECT 1::int") + .fetch_one(&self.pool) + .await + { + Ok(_) => Ok(HealthStatus::Healthy), + Err(sqlx::Error::PoolTimedOut) => Ok(HealthStatus::Degraded { + reason: "pool exhausted".to_string(), + }), + Err(e) => Ok(HealthStatus::Unavailable { + reason: e.to_string(), + }), + } +} +``` + +### Embedding-model registry + +#### `registered_model` + +```rust +async fn registered_model(&self) -> MemoryStoreResult> +``` + +Thin pass-through to `registry::fetch_registry`. The Postgres backend +does not cache the row in-memory the way the SQLite backend does -- +sqlx's prepared-statement cache already keeps the SELECT cheap, and +`registered_model` is not on the hot path. + +```rust +async fn registered_model(&self) -> MemoryStoreResult> { + crate::storage::postgres::registry::fetch_registry(&self.pool).await +} +``` + +#### `register_model` + +```rust +async fn register_model(&self, sig: &ModelSignature) -> MemoryStoreResult<()> +``` + +Delegate to `registry::ensure_registry`, which handles the +"insert + stamp typmod" first-run path and the "compare" subsequent path. + +```rust +async fn register_model(&self, sig: &ModelSignature) -> MemoryStoreResult<()> { + crate::storage::postgres::registry::ensure_registry(&self.pool, sig).await +} +``` + +### CRUD + +#### `insert` + +```rust +async fn insert(&self, record: &MemoryRecord) -> MemoryStoreResult +``` + +Single `INSERT` into `knowledge_nodes` with all D7+D8 columns. Bind embedding +as `Option` -- pgvector's sqlx integration handles the +typmod check at execution time, so a length mismatch surfaces as +`MemoryStoreError::Postgres`. The caller-supplied UUID is preserved +(same contract as SQLite). Initial scheduling state is inserted in the +same transaction so a memory is never queryable without a scheduling +row. + +```rust +async fn insert(&self, record: &MemoryRecord) -> MemoryStoreResult { + let embedding: Option = record + .embedding + .as_ref() + .map(|v| Vector::from(v.clone())); + let domain_scores = serde_json::to_value(&record.domain_scores) + .unwrap_or_else(|_| serde_json::json!({})); + + let mut tx = self.pool.begin().await?; + + sqlx::query!( + r#" + INSERT INTO knowledge_nodes ( + id, + owner_user_id, + visibility, + shared_with_groups, + codebase, + content, + node_type, + tags, + domains, + domain_scores, + embedding, + metadata, + created_at, + updated_at + ) + VALUES ( + $1, $2, $3, $4, $5, $6, $7, $8, $9, $10::jsonb, + $11, $12::jsonb, $13, $14 + ) + "#, + record.id, + record.owner_user_id, + record.visibility.as_str(), + &record.shared_with_groups as &[Uuid], + record.codebase.as_deref(), + record.content, + record.node_type, + &record.tags as &[String], + &record.domains as &[String], + domain_scores, + embedding as Option, + record.metadata, + record.created_at, + record.updated_at, + ) + .execute(&mut *tx) + .await?; + + // Seed scheduling state. Mirrors SQLite defaults from `knowledge_nodes` + // (stability=1.0, difficulty=0.3, retrievability=1.0, reps=0, lapses=0, + // next_review = created_at + 1 day). + sqlx::query!( + r#" + INSERT INTO scheduling ( + memory_id, stability, difficulty, retrievability, + last_review, next_review, reps, lapses + ) + VALUES ($1, 1.0, 0.3, 1.0, NULL, $2, 0, 0) + "#, + record.id, + record.created_at + chrono::Duration::days(1), + ) + .execute(&mut *tx) + .await?; + + tx.commit().await?; + Ok(record.id) +} +``` + +Tricky bits: +- `&record.tags as &[String]` -- sqlx requires an explicit slice cast + to bind a `Vec` as `text[]`. +- `&record.shared_with_groups as &[Uuid]` -- same pattern for `uuid[]`. +- `embedding as Option` -- type annotation is mandatory in the + macro because the inference path bottoms out at a generic; pgvector's + `Encode` impl resolves only with a known concrete type. +- The `$10::jsonb` and `$12::jsonb` casts force sqlx to encode through + the JSONB path even if the parameter type-resolves to `JSON`. This + matters because the migrations created the columns as `JSONB`, and + sqlx 0.8 does not always pick JSONB without the cast. + +#### `get` + +```rust +async fn get(&self, id: Uuid) -> MemoryStoreResult> +``` + +`SELECT *` filtered by primary key. Row mapping goes through +`row_to_record`. + +```rust +async fn get(&self, id: Uuid) -> MemoryStoreResult> { + let row = sqlx::query!( + r#" + SELECT + id AS "id!: Uuid", + owner_user_id AS "owner_user_id!: Uuid", + visibility, + shared_with_groups AS "shared_with_groups!: Vec", + codebase, + content, + node_type, + tags AS "tags!: Vec", + domains AS "domains!: Vec", + domain_scores AS "domain_scores!: serde_json::Value", + embedding AS "embedding: Vector", + metadata AS "metadata!: serde_json::Value", + created_at AS "created_at!: DateTime", + updated_at AS "updated_at!: DateTime" + FROM knowledge_nodes + WHERE id = $1 + "#, + id, + ) + .fetch_optional(&self.pool) + .await?; + + let Some(r) = row else { return Ok(None) }; + + Ok(Some(row_to_record( + r.id, r.content, r.node_type, r.tags, r.domains, + r.domain_scores, r.codebase, r.owner_user_id, r.visibility, + r.shared_with_groups, r.embedding, r.metadata, + r.created_at, r.updated_at, + )?)) +} +``` + +The `AS "name!: Type"` annotations tell sqlx the exact Rust type for +each column, which is required for `Vec` (from `uuid[]`) and +`Vector` (from `vector`). The `!` means "trust me, this column is NOT +NULL"; sqlx skips its `Option` wrapping for those columns. The +`embedding` column is nullable, so it gets `Option` (no `!`). + +#### `update` + +```rust +async fn update(&self, record: &MemoryRecord) -> MemoryStoreResult<()> +``` + +Update everything the caller might have changed. `updated_at` is set +server-side via `now()` so clock drift between hosts does not leak into +the timeline. (If the caller wants to forge `updated_at` -- e.g. the +migrate CLI replaying SQLite timestamps -- it goes through `insert`, not +`update`.) The schema's `BEFORE UPDATE` trigger could replace this; we +write `updated_at = now()` explicitly to be backend-agnostic. + +```rust +async fn update(&self, record: &MemoryRecord) -> MemoryStoreResult<()> { + let embedding: Option = record + .embedding + .as_ref() + .map(|v| Vector::from(v.clone())); + let domain_scores = serde_json::to_value(&record.domain_scores) + .unwrap_or_else(|_| serde_json::json!({})); + + let rows = sqlx::query!( + r#" + UPDATE knowledge_nodes SET + owner_user_id = $2, + visibility = $3, + shared_with_groups = $4, + codebase = $5, + content = $6, + node_type = $7, + tags = $8, + domains = $9, + domain_scores = $10::jsonb, + embedding = $11, + metadata = $12::jsonb, + updated_at = now() + WHERE id = $1 + "#, + record.id, + record.owner_user_id, + record.visibility.as_str(), + &record.shared_with_groups as &[Uuid], + record.codebase.as_deref(), + record.content, + record.node_type, + &record.tags as &[String], + &record.domains as &[String], + domain_scores, + embedding as Option, + record.metadata, + ) + .execute(&self.pool) + .await? + .rows_affected(); + + if rows == 0 { + return Err(MemoryStoreError::NotFound(record.id.to_string())); + } + Ok(()) +} +``` + +#### `delete` + +```rust +async fn delete(&self, id: Uuid) -> MemoryStoreResult<()> +``` + +Single `DELETE` by id. `scheduling`, `edges`, and `review_events` all +have `ON DELETE CASCADE` on their `memory_id` foreign key, so this one +statement clears every dependent row. + +```rust +async fn delete(&self, id: Uuid) -> MemoryStoreResult<()> { + let rows = sqlx::query!( + "DELETE FROM knowledge_nodes WHERE id = $1", + id, + ) + .execute(&self.pool) + .await? + .rows_affected(); + + if rows == 0 { + return Err(MemoryStoreError::NotFound(id.to_string())); + } + Ok(()) +} +``` + +### Search (single-branch variants) + +The full hybrid `search` is implemented in `0002e-hybrid-search.md`. +The two single-branch variants below ship in this sub-plan. + +#### `fts_search` + +```rust +async fn fts_search(&self, text: &str, limit: usize) -> MemoryStoreResult> +``` + +PostgreSQL full-text search using the precomputed `search_vec` tsvector +column and `websearch_to_tsquery` (handles bare words, phrases, and +boolean operators). Ranking with `ts_rank_cd` (cover-density) so longer +matches outrank shorter ones; the SQLite backend uses BM25 from FTS5 but +the trait contract only requires "higher is better". + +```rust +async fn fts_search( + &self, + text: &str, + limit: usize, +) -> MemoryStoreResult> { + let limit = limit.min(1000) as i64; + let rows = sqlx::query!( + r#" + SELECT + m.id AS "id!: Uuid", + m.owner_user_id AS "owner_user_id!: Uuid", + m.visibility, + m.shared_with_groups AS "shared_with_groups!: Vec", + m.codebase, + m.content, + m.node_type, + m.tags AS "tags!: Vec", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.embedding AS "embedding: Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: DateTime", + m.updated_at AS "updated_at!: DateTime", + ts_rank_cd(m.search_vec, websearch_to_tsquery('english', $1)) + AS "score!: f64" + FROM knowledge_nodes m + WHERE m.search_vec @@ websearch_to_tsquery('english', $1) + ORDER BY score DESC + LIMIT $2 + "#, + text, + limit, + ) + .fetch_all(&self.pool) + .await?; + + let mut out = Vec::with_capacity(rows.len()); + for r in rows { + let rec = row_to_record( + r.id, r.content, r.node_type, r.tags, r.domains, + r.domain_scores, r.codebase, r.owner_user_id, r.visibility, + r.shared_with_groups, r.embedding, r.metadata, + r.created_at, r.updated_at, + )?; + out.push(SearchResult { + record: rec, + score: r.score, + fts_score: Some(r.score), + vector_score: None, + }); + } + Ok(out) +} +``` + +The `'english'` text-search configuration matches the GIN index built in +`0001_init.up.sql`. If a future migration parameterises the config, both +the index and this query change together. + +#### `vector_search` + +```rust +async fn vector_search(&self, embedding: &[f32], limit: usize) -> MemoryStoreResult> +``` + +pgvector cosine distance. The HNSW index on `embedding` (built in +`0002_hnsw.up.sql` with `vector_cosine_ops`) makes the `<=>` operator +index-accelerated. We convert the returned distance (0 = identical, 2 = +opposite for cosine on normalized vectors) to a similarity in `[0, 1]` +via `1 - distance`; this matches the SQLite backend's convention. + +```rust +async fn vector_search( + &self, + embedding: &[f32], + limit: usize, +) -> MemoryStoreResult> { + let query_vec = Vector::from(embedding.to_vec()); + let limit = limit.min(1000) as i64; + + let rows = sqlx::query!( + r#" + SELECT + m.id AS "id!: Uuid", + m.owner_user_id AS "owner_user_id!: Uuid", + m.visibility, + m.shared_with_groups AS "shared_with_groups!: Vec", + m.codebase, + m.content, + m.node_type, + m.tags AS "tags!: Vec", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.embedding AS "embedding: Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: DateTime", + m.updated_at AS "updated_at!: DateTime", + (1.0 - (m.embedding <=> $1)) AS "score!: f64" + FROM knowledge_nodes m + WHERE m.embedding IS NOT NULL + ORDER BY m.embedding <=> $1 + LIMIT $2 + "#, + query_vec as Vector, + limit, + ) + .fetch_all(&self.pool) + .await?; + + let mut out = Vec::with_capacity(rows.len()); + for r in rows { + let rec = row_to_record( + r.id, r.content, r.node_type, r.tags, r.domains, + r.domain_scores, r.codebase, r.owner_user_id, r.visibility, + r.shared_with_groups, r.embedding, r.metadata, + r.created_at, r.updated_at, + )?; + out.push(SearchResult { + record: rec, + score: r.score, + fts_score: None, + vector_score: Some(r.score), + }); + } + Ok(out) +} +``` + +The `query_vec as Vector` cast is the same type-annotation trick as +`insert` -- sqlx needs the concrete pgvector type to wire up encoding. +The `ORDER BY m.embedding <=> $1` (no `score`) is intentional: it lets +the HNSW index serve the query directly. Sorting by the computed +`score` column would force a sequential scan because the index orders +by distance, not similarity. + +### Scheduling + +The Postgres `scheduling` table is a separate row keyed on `memory_id`, +not embedded in `knowledge_nodes` (unlike SQLite where FSRS columns live on +`knowledge_nodes`). The bodies abstract that difference at the SQL +boundary; callers see the same `SchedulingState` value. + +#### `get_scheduling` + +```rust +async fn get_scheduling(&self, memory_id: Uuid) -> MemoryStoreResult> +``` + +```rust +async fn get_scheduling( + &self, + memory_id: Uuid, +) -> MemoryStoreResult> { + let row = sqlx::query!( + r#" + SELECT + memory_id AS "memory_id!: Uuid", + stability AS "stability!: f64", + difficulty AS "difficulty!: f64", + retrievability AS "retrievability!: f64", + last_review AS "last_review: DateTime", + next_review AS "next_review: DateTime", + reps AS "reps!: i32", + lapses AS "lapses!: i32" + FROM scheduling + WHERE memory_id = $1 + "#, + memory_id, + ) + .fetch_optional(&self.pool) + .await?; + + Ok(row.map(|r| SchedulingState { + memory_id: r.memory_id, + stability: r.stability, + difficulty: r.difficulty, + retrievability: r.retrievability, + last_review: r.last_review, + next_review: r.next_review, + reps: r.reps as u32, + lapses: r.lapses as u32, + })) +} +``` + +#### `update_scheduling` + +```rust +async fn update_scheduling(&self, state: &SchedulingState) -> MemoryStoreResult<()> +``` + +Upsert -- the `INSERT ... ON CONFLICT DO UPDATE` form -- so cognitive +modules that update scheduling for a freshly-inserted memory don't have +to race with the seed row from `insert`. + +```rust +async fn update_scheduling( + &self, + state: &SchedulingState, +) -> MemoryStoreResult<()> { + sqlx::query!( + r#" + INSERT INTO scheduling ( + memory_id, stability, difficulty, retrievability, + last_review, next_review, reps, lapses + ) + VALUES ($1, $2, $3, $4, $5, $6, $7, $8) + ON CONFLICT (memory_id) DO UPDATE SET + stability = EXCLUDED.stability, + difficulty = EXCLUDED.difficulty, + retrievability = EXCLUDED.retrievability, + last_review = EXCLUDED.last_review, + next_review = EXCLUDED.next_review, + reps = EXCLUDED.reps, + lapses = EXCLUDED.lapses + "#, + state.memory_id, + state.stability, + state.difficulty, + state.retrievability, + state.last_review, + state.next_review, + state.reps as i32, + state.lapses as i32, + ) + .execute(&self.pool) + .await?; + Ok(()) +} +``` + +#### `get_due_memories` + +```rust +async fn get_due_memories( + &self, + before: DateTime, + limit: usize, +) -> MemoryStoreResult> +``` + +Join `knowledge_nodes` and `scheduling`, filter on `next_review <= before`. +Single query returns both halves of the tuple. + +```rust +async fn get_due_memories( + &self, + before: DateTime, + limit: usize, +) -> MemoryStoreResult> { + let limit = limit.min(10_000) as i64; + let rows = sqlx::query!( + r#" + SELECT + m.id AS "id!: Uuid", + m.owner_user_id AS "owner_user_id!: Uuid", + m.visibility, + m.shared_with_groups AS "shared_with_groups!: Vec", + m.codebase, + m.content, + m.node_type, + m.tags AS "tags!: Vec", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.embedding AS "embedding: Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: DateTime", + m.updated_at AS "updated_at!: DateTime", + s.stability AS "stability!: f64", + s.difficulty AS "difficulty!: f64", + s.retrievability AS "retrievability!: f64", + s.last_review AS "last_review: DateTime", + s.next_review AS "next_review: DateTime", + s.reps AS "reps!: i32", + s.lapses AS "lapses!: i32" + FROM knowledge_nodes m + JOIN scheduling s ON s.memory_id = m.id + WHERE s.next_review IS NOT NULL AND s.next_review <= $1 + ORDER BY s.next_review ASC + LIMIT $2 + "#, + before, + limit, + ) + .fetch_all(&self.pool) + .await?; + + let mut out = Vec::with_capacity(rows.len()); + for r in rows { + let rec = row_to_record( + r.id, r.content, r.node_type, r.tags, r.domains, + r.domain_scores, r.codebase, r.owner_user_id, r.visibility, + r.shared_with_groups, r.embedding, r.metadata, + r.created_at, r.updated_at, + )?; + let state = SchedulingState { + memory_id: rec.id, + stability: r.stability, + difficulty: r.difficulty, + retrievability: r.retrievability, + last_review: r.last_review, + next_review: r.next_review, + reps: r.reps as u32, + lapses: r.lapses as u32, + }; + out.push((rec, state)); + } + Ok(out) +} +``` + +### Graph (edges) + +#### `add_edge` + +```rust +async fn add_edge(&self, edge: &MemoryEdge) -> MemoryStoreResult<()> +``` + +`INSERT ... ON CONFLICT` -- updating the weight if an edge already +exists (matches SQLite's `save_connection` semantics). + +```rust +async fn add_edge(&self, edge: &MemoryEdge) -> MemoryStoreResult<()> { + sqlx::query!( + r#" + INSERT INTO edges ( + source_id, target_id, edge_type, weight, created_at + ) + VALUES ($1, $2, $3, $4, $5) + ON CONFLICT (source_id, target_id, edge_type) DO UPDATE SET + weight = EXCLUDED.weight + "#, + edge.source_id, + edge.target_id, + edge.edge_type, + edge.weight, + edge.created_at, + ) + .execute(&self.pool) + .await?; + Ok(()) +} +``` + +#### `get_edges` + +```rust +async fn get_edges( + &self, + node_id: Uuid, + edge_type: Option<&str>, +) -> MemoryStoreResult> +``` + +Return every edge incident to `node_id` in either direction, optionally +filtered by `edge_type`. The optional filter binds as nullable; `$2 IS +NULL OR edge_type = $2` keeps the prepared statement reusable. + +```rust +async fn get_edges( + &self, + node_id: Uuid, + edge_type: Option<&str>, +) -> MemoryStoreResult> { + let rows = sqlx::query!( + r#" + SELECT + source_id AS "source_id!: Uuid", + target_id AS "target_id!: Uuid", + edge_type, + weight AS "weight!: f64", + created_at AS "created_at!: DateTime" + FROM edges + WHERE (source_id = $1 OR target_id = $1) + AND ($2::text IS NULL OR edge_type = $2) + "#, + node_id, + edge_type, + ) + .fetch_all(&self.pool) + .await?; + + Ok(rows + .into_iter() + .map(|r| MemoryEdge { + source_id: r.source_id, + target_id: r.target_id, + edge_type: r.edge_type, + weight: r.weight, + created_at: r.created_at, + }) + .collect()) +} +``` + +#### `remove_edge` + +```rust +async fn remove_edge(&self, source: Uuid, target: Uuid) -> MemoryStoreResult<()> +``` + +Note: the live trait signature is two args (`source`, `target`). The +master plan's stale three-arg signature including `edge_type` is not +implemented -- the live trait surface wins. Deletes every edge between +the pair regardless of `edge_type`. + +```rust +async fn remove_edge( + &self, + source: Uuid, + target: Uuid, +) -> MemoryStoreResult<()> { + sqlx::query!( + "DELETE FROM edges WHERE source_id = $1 AND target_id = $2", + source, + target, + ) + .execute(&self.pool) + .await?; + Ok(()) +} +``` + +#### `get_neighbors` + +```rust +async fn get_neighbors( + &self, + node_id: Uuid, + depth: usize, +) -> MemoryStoreResult> +``` + +Recursive CTE walks the edge graph outward from `node_id` for up to +`depth` hops. Weights compound multiplicatively along the path (same as +SQLite BFS). Cap the visited set at 256 rows to match SQLite. Direction +is treated as undirected by unioning both halves of each edge inside +the CTE. + +```rust +async fn get_neighbors( + &self, + node_id: Uuid, + depth: usize, +) -> MemoryStoreResult> { + if depth == 0 { + let Some(rec) = self.get(node_id).await? else { + return Err(MemoryStoreError::NotFound(node_id.to_string())); + }; + return Ok(vec![(rec, 1.0)]); + } + + let depth_i = depth.min(16) as i32; + let rows = sqlx::query!( + r#" + WITH RECURSIVE walk(node_id, weight, hops) AS ( + SELECT $1::uuid, 1.0::float8, 0 + UNION ALL + SELECT + CASE WHEN e.source_id = w.node_id THEN e.target_id + ELSE e.source_id END, + w.weight * e.weight, + w.hops + 1 + FROM walk w + JOIN edges e + ON e.source_id = w.node_id OR e.target_id = w.node_id + WHERE w.hops < $2 + ), + best AS ( + SELECT node_id, MAX(weight) AS weight + FROM walk + GROUP BY node_id + LIMIT 256 + ) + SELECT + m.id AS "id!: Uuid", + m.owner_user_id AS "owner_user_id!: Uuid", + m.visibility, + m.shared_with_groups AS "shared_with_groups!: Vec", + m.codebase, + m.content, + m.node_type, + m.tags AS "tags!: Vec", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.embedding AS "embedding: Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: DateTime", + m.updated_at AS "updated_at!: DateTime", + b.weight AS "weight!: f64" + FROM best b + JOIN knowledge_nodes m ON m.id = b.node_id + "#, + node_id, + depth_i, + ) + .fetch_all(&self.pool) + .await?; + + let mut out = Vec::with_capacity(rows.len()); + for r in rows { + let rec = row_to_record( + r.id, r.content, r.node_type, r.tags, r.domains, + r.domain_scores, r.codebase, r.owner_user_id, r.visibility, + r.shared_with_groups, r.embedding, r.metadata, + r.created_at, r.updated_at, + )?; + out.push((rec, r.weight)); + } + Ok(out) +} +``` + +The CTE can visit a node multiple times via different paths; the `best` +sub-CTE picks the highest weight per node. The `LIMIT 256` matches the +SQLite BFS cap. Postgres' recursive CTE is breadth-first by hop count +because of the `WHERE w.hops < $2` predicate. + +### Domains (Phase 4 populates; Phase 2 ships CRUD) + +The `domains` table is empty in Phase 2; these methods exist so the +trait surface is complete but they do not get exercised until Phase 4 +HDBSCAN clustering runs. + +#### `list_domains` + +```rust +async fn list_domains(&self) -> MemoryStoreResult> +``` + +```rust +async fn list_domains(&self) -> MemoryStoreResult> { + let rows = sqlx::query!( + r#" + SELECT + id, + label, + centroid AS "centroid: Vector", + top_terms AS "top_terms!: Vec", + memory_count AS "memory_count!: i64", + created_at AS "created_at!: DateTime" + FROM domains + ORDER BY created_at ASC + "# + ) + .fetch_all(&self.pool) + .await?; + + Ok(rows + .into_iter() + .map(|r| Domain { + id: r.id, + label: r.label, + centroid: r.centroid.map(|v| v.to_vec()).unwrap_or_default(), + top_terms: r.top_terms, + memory_count: r.memory_count as usize, + created_at: r.created_at, + }) + .collect()) +} +``` + +#### `get_domain` + +```rust +async fn get_domain(&self, id: &str) -> MemoryStoreResult> +``` + +```rust +async fn get_domain(&self, id: &str) -> MemoryStoreResult> { + let row = sqlx::query!( + r#" + SELECT + id, + label, + centroid AS "centroid: Vector", + top_terms AS "top_terms!: Vec", + memory_count AS "memory_count!: i64", + created_at AS "created_at!: DateTime" + FROM domains + WHERE id = $1 + "#, + id, + ) + .fetch_optional(&self.pool) + .await?; + + Ok(row.map(|r| Domain { + id: r.id, + label: r.label, + centroid: r.centroid.map(|v| v.to_vec()).unwrap_or_default(), + top_terms: r.top_terms, + memory_count: r.memory_count as usize, + created_at: r.created_at, + })) +} +``` + +#### `upsert_domain` + +```rust +async fn upsert_domain(&self, domain: &Domain) -> MemoryStoreResult<()> +``` + +```rust +async fn upsert_domain(&self, domain: &Domain) -> MemoryStoreResult<()> { + let centroid = if domain.centroid.is_empty() { + None + } else { + Some(Vector::from(domain.centroid.clone())) + }; + + sqlx::query!( + r#" + INSERT INTO domains ( + id, label, centroid, top_terms, memory_count, created_at + ) + VALUES ($1, $2, $3, $4, $5, $6) + ON CONFLICT (id) DO UPDATE SET + label = EXCLUDED.label, + centroid = EXCLUDED.centroid, + top_terms = EXCLUDED.top_terms, + memory_count = EXCLUDED.memory_count + "#, + domain.id, + domain.label, + centroid as Option, + &domain.top_terms as &[String], + domain.memory_count as i64, + domain.created_at, + ) + .execute(&self.pool) + .await?; + Ok(()) +} +``` + +#### `delete_domain` + +```rust +async fn delete_domain(&self, id: &str) -> MemoryStoreResult<()> +``` + +```rust +async fn delete_domain(&self, id: &str) -> MemoryStoreResult<()> { + sqlx::query!( + "DELETE FROM domains WHERE id = $1", + id, + ) + .execute(&self.pool) + .await?; + Ok(()) +} +``` + +#### `classify` + +```rust +async fn classify(&self, embedding: &[f32]) -> MemoryStoreResult> +``` + +The Postgres backend can ship this as a single SQL query against the +empty `domains` table -- it correctly returns an empty vector in Phase +2 and starts returning real scores in Phase 4 without any code change. + +```rust +async fn classify( + &self, + embedding: &[f32], +) -> MemoryStoreResult> { + let query_vec = Vector::from(embedding.to_vec()); + let rows = sqlx::query!( + r#" + SELECT + id, + (1.0 - (centroid <=> $1)) AS "score!: f64" + FROM domains + WHERE centroid IS NOT NULL + ORDER BY score DESC + "#, + query_vec as Vector, + ) + .fetch_all(&self.pool) + .await?; + + Ok(rows.into_iter().map(|r| (r.id, r.score)).collect()) +} +``` + +### Bulk / maintenance + +#### `count` + +```rust +async fn count(&self) -> MemoryStoreResult +``` + +```rust +async fn count(&self) -> MemoryStoreResult { + let n: i64 = sqlx::query_scalar!("SELECT COUNT(*) FROM knowledge_nodes") + .fetch_one(&self.pool) + .await? + .unwrap_or(0); + Ok(n as usize) +} +``` + +#### `get_stats` + +```rust +async fn get_stats(&self) -> MemoryStoreResult +``` + +Aggregate counts across `knowledge_nodes`, `edges`, `domains`. Read the +registry inline. + +```rust +async fn get_stats(&self) -> MemoryStoreResult { + let row = sqlx::query!( + r#" + SELECT + (SELECT COUNT(*) FROM knowledge_nodes) + AS "total_memories!: i64", + (SELECT COUNT(*) FROM knowledge_nodes WHERE embedding IS NOT NULL) + AS "memories_with_embeddings!: i64", + (SELECT COUNT(*) FROM edges) + AS "total_edges!: i64", + (SELECT COUNT(*) FROM domains) + AS "total_domains!: i64", + (SELECT name FROM embedding_model WHERE id = 1) + AS "registered_model_name: String", + (SELECT dimension FROM embedding_model WHERE id = 1) + AS "registered_model_dim: i32" + "# + ) + .fetch_one(&self.pool) + .await?; + + Ok(StoreStats { + total_memories: row.total_memories as usize, + memories_with_embeddings: row.memories_with_embeddings as usize, + total_edges: row.total_edges as usize, + total_domains: row.total_domains as usize, + registered_model_name: row.registered_model_name, + registered_model_dim: row.registered_model_dim.map(|d| d as usize), + }) +} +``` + +#### `vacuum` + +```rust +async fn vacuum(&self) -> MemoryStoreResult<()> +``` + +`VACUUM` cannot run inside a transaction. sqlx wraps each `query!` +invocation in an implicit transaction when it grabs a pooled +connection, but it does not -- the pool hands out a raw connection +that runs statements in autocommit mode by default. The safe path is +to acquire a connection explicitly and `execute` each statement +separately so neither participates in a transaction. + +```rust +async fn vacuum(&self) -> MemoryStoreResult<()> { + let mut conn = self.pool.acquire().await?; + sqlx::query("VACUUM ANALYZE knowledge_nodes") + .execute(conn.as_mut()) + .await?; + sqlx::query("VACUUM ANALYZE scheduling") + .execute(conn.as_mut()) + .await?; + sqlx::query("VACUUM ANALYZE edges") + .execute(conn.as_mut()) + .await?; + Ok(()) +} +``` + +`conn.as_mut()` yields a `&mut PgConnection`, which sqlx accepts as an +executor. Using `&self.pool` here would let sqlx pick a fresh +connection per statement (still fine, but two extra acquisitions). Note +we do NOT vacuum `domains`, `edges`-related lookup tables (`users` / +`groups` etc.) -- they are either empty in Phase 2 or low-churn and the +nightly autovacuum suffices. + +--- + +## Visibility filter posture + +ADR 0002 D7 declares the future Phase 3 visibility filter (reproduced +here for clarity): + +```sql +WHERE + (visibility = 'private' AND owner_user_id = $me) + OR (visibility = 'group' + AND (owner_user_id = $me OR shared_with_groups && $my_group_ids)) + OR visibility = 'public' +``` + +**Phase 2 does NOT apply this filter.** Every body above reads and +writes the rows it touches regardless of `owner_user_id` or +`visibility` because there is exactly one user in Phase 2 mode (the +bootstrap user from `0001_init.up.sql`). The reviewer should NOT expect +`WHERE owner_user_id = $...` clauses in Phase 2 method bodies. + +Phase 3 introduces an `AuthContext` parameter on the trait methods and +threads it into each WHERE clause. That migration is purely additive +(adds a parameter, adds a clause); it does not need a schema migration +because the columns and indexes are already in place. + +The four new `MemoryRecord` fields ARE populated correctly in Phase 2 +(insert writes them, get/search read them) so that exported archives +and replicated rows round-trip the visibility intent the moment Phase +3 enables filtering. + +--- + +## Offline sqlx cache + +`sqlx::query!` and `sqlx::query_as!` validate every SQL string at +compile time by contacting a live database. To keep CI builds from +needing a Postgres on the build host, sqlx supports an offline cache +in `/.sqlx/` containing one JSON file per validated query. + +This sub-plan is where `.sqlx/` is first populated and committed. + +Workflow: + +1. Ensure a local Postgres is running with the same schema CI will see: + + ```bash + cd crates/vestige-core + export DATABASE_URL="postgres://vestige:vestige@127.0.0.1:5432/vestige_dev" + sqlx database create + sqlx migrate run --source migrations/postgres + ``` + +2. Generate the offline cache: + + ```bash + cargo sqlx prepare --workspace -- --features postgres-backend + ``` + + This walks every `sqlx::query!` invocation under the active feature + flags and writes `crates/vestige-core/.sqlx/query-.json`. The + `--workspace` flag is needed because `vestige-mcp` enables the + `postgres-backend` feature transitively in `0002b-pool-and-config.md`. + +3. Stage and commit the cache directory: + + ```bash + git add crates/vestige-core/.sqlx/ + git commit -m "store: populate sqlx offline cache for postgres backend" + ``` + +4. Add to repo `.gitignore` adjustments (only if entries already deny + `target/` or similar globs): leave `.sqlx/` excluded from any + ignore globs. Specifically the workspace root `.gitignore` does NOT + contain a `.sqlx` line; if a future PR adds one, this sub-plan's + commit reverts it. + +5. CI runs `SQLX_OFFLINE=true cargo check --features postgres-backend`. + sqlx falls back to the JSON cache when `SQLX_OFFLINE=true` is set, + so CI does not need network access to a Postgres. + +Every time a `query!` invocation changes -- add a column, change a +WHERE clause, rename a binding -- re-run `cargo sqlx prepare` and +commit the updated `.sqlx/` files. The agent implementing this sub-plan +runs `cargo sqlx prepare` as the last step before opening the PR. + +--- + +## Verification + +Three layers of verification before merging this sub-plan. + +### 1. Compile and lint + +```bash +cargo check --workspace --features postgres-backend +cargo build --workspace --features postgres-backend +cargo clippy --workspace --features postgres-backend -- -D warnings + +# SQLite-only build still works (mutual compilability per CLAUDE.md): +cargo check --workspace --no-default-features --features embeddings,vector-search +``` + +### 2. Offline cache builds + +```bash +SQLX_OFFLINE=true cargo check --workspace --features postgres-backend +``` + +This is what CI will run. If it fails, `cargo sqlx prepare` was not +re-run after the last query change. + +### 3. Integration round-trip test (testcontainers) + +New test file: +`crates/vestige-core/tests/postgres_round_trip.rs`. Skipped unless the +`postgres-backend` feature is active and Docker / Podman is available. + +```rust +#![cfg(feature = "postgres-backend")] + +use chrono::Utc; +use testcontainers::{clients, GenericImage}; +use uuid::Uuid; +use vestige_core::storage::memory_store::{ + LocalMemoryStore, MemoryEdge, MemoryRecord, SchedulingState, Visibility, + LOCAL_USER_ID, +}; +use vestige_core::storage::postgres::PgMemoryStore; + +#[tokio::test] +async fn round_trip_crud_search_scheduling_edges() { + let docker = clients::Cli::default(); + let image = GenericImage::new("pgvector/pgvector", "pg16") + .with_env_var("POSTGRES_PASSWORD", "test") + .with_env_var("POSTGRES_DB", "vestige_test") + .with_exposed_port(5432); + let container = docker.run(image); + let port = container.get_host_port_ipv4(5432); + let url = format!("postgres://postgres:test@127.0.0.1:{port}/vestige_test"); + + let store = PgMemoryStore::connect(&url, 5).await.expect("connect"); + + // Register the model (typmod stamp). + store.register_model(&fixture_signature(384)).await.expect("register"); + + // insert -> get -> update -> delete. + let mut rec = fixture_record(); + let id = store.insert(&rec).await.expect("insert"); + let fetched = store.get(id).await.expect("get").expect("present"); + assert_eq!(fetched.content, rec.content); + assert_eq!(fetched.owner_user_id, LOCAL_USER_ID); + assert_eq!(fetched.visibility, Visibility::Private); + + rec.content = "edited".to_string(); + store.update(&rec).await.expect("update"); + assert_eq!(store.get(id).await.unwrap().unwrap().content, "edited"); + + // fts_search. + let hits = store.fts_search("edited", 10).await.expect("fts"); + assert!(hits.iter().any(|h| h.record.id == id)); + + // vector_search. + let emb = rec.embedding.clone().unwrap(); + let vhits = store.vector_search(&emb, 10).await.expect("vector"); + assert!(vhits.iter().any(|h| h.record.id == id)); + + // scheduling round-trip. + let sched = store.get_scheduling(id).await.unwrap().expect("seeded"); + let new_state = SchedulingState { + memory_id: id, + stability: 5.5, + difficulty: 0.2, + retrievability: 0.95, + last_review: Some(Utc::now()), + next_review: Some(Utc::now() + chrono::Duration::days(3)), + reps: sched.reps + 1, + lapses: sched.lapses, + }; + store.update_scheduling(&new_state).await.expect("update sched"); + let after = store.get_scheduling(id).await.unwrap().unwrap(); + assert_eq!(after.reps, new_state.reps); + + // edges. + let other = fixture_record(); + let other_id = store.insert(&other).await.unwrap(); + let edge = MemoryEdge { + source_id: id, + target_id: other_id, + edge_type: "semantic".to_string(), + weight: 0.8, + created_at: Utc::now(), + }; + store.add_edge(&edge).await.expect("add_edge"); + let edges = store.get_edges(id, None).await.unwrap(); + assert_eq!(edges.len(), 1); + let neighbors = store.get_neighbors(id, 1).await.unwrap(); + assert!(neighbors.iter().any(|(r, _)| r.id == other_id)); + store.remove_edge(id, other_id).await.expect("remove_edge"); + assert!(store.get_edges(id, None).await.unwrap().is_empty()); + + // delete -> cascade. + store.delete(id).await.expect("delete"); + assert!(store.get(id).await.unwrap().is_none()); + assert!(store.get_scheduling(id).await.unwrap().is_none()); +} + +fn fixture_record() -> MemoryRecord { + MemoryRecord { + id: Uuid::new_v4(), + domains: vec![], + domain_scores: Default::default(), + content: "the quick brown fox jumps over the lazy dog".into(), + node_type: "fact".into(), + tags: vec!["test".into()], + embedding: Some(vec![0.1_f32; 384]), + created_at: Utc::now(), + updated_at: Utc::now(), + metadata: serde_json::json!({}), + owner_user_id: LOCAL_USER_ID, + visibility: Visibility::Private, + shared_with_groups: vec![], + codebase: Some("vestige".to_string()), + } +} + +fn fixture_signature(dim: usize) -> vestige_core::storage::memory_store::ModelSignature { + vestige_core::storage::memory_store::ModelSignature { + name: "test/model".to_string(), + dimension: dim, + hash: "0".repeat(64), + } +} +``` + +Add `testcontainers = "0.20"` to `[dev-dependencies]` under +`#[cfg(feature = "postgres-backend")]` gating. The test is the slowest +in the suite (spawns a Docker container, ~5 s startup); annotate with +`#[ignore]` if CI runtime budget requires opt-in execution. + +### 4. Manual smoke (optional but recommended) + +```bash +# Tear down any prior database. +make postgres-down ; make postgres-up +DATABASE_URL=$(make postgres-url) cargo test \ + -p vestige-core --features postgres-backend -- --include-ignored +``` + +The `postgres-up` / `postgres-down` / `postgres-url` make targets are +defined in `docs/plans/local-dev-postgres-setup.md`. + +--- + +## Acceptance criteria + +This sub-plan is complete when ALL of the following hold: + +1. `cargo build --workspace --features postgres-backend` succeeds with + zero warnings. +2. `cargo clippy --workspace --features postgres-backend -- -D warnings` + succeeds. +3. `cargo build --workspace --no-default-features --features embeddings,vector-search` + still succeeds (the SQLite-only build is not regressed). +4. `SQLX_OFFLINE=true cargo check --workspace --features postgres-backend` + succeeds. `crates/vestige-core/.sqlx/` exists and contains one JSON + file per `sqlx::query!` / `sqlx::query_as!` invocation in the + Postgres backend. +5. Zero `todo!()` macros remain in + `crates/vestige-core/src/storage/postgres/mod.rs`. The only + exception is the body of the trait method `search` -- that method + stays `todo!()` until `0002e-hybrid-search.md` lands. +6. `crates/vestige-core/src/storage/postgres/registry.rs` exists with + the three functions described above + (`fetch_registry`, `ensure_registry`, `update_registry_for_reembed`). +7. `MemoryRecord` carries the four new fields + (`owner_user_id`, `visibility`, `shared_with_groups`, `codebase`) + and the `Visibility` enum is exported alongside it. The SQLite + backend reads and writes the same four fields. +8. The `tests/postgres_round_trip.rs` integration test passes against + a `pgvector/pgvector:pg16` container (insert / get / update / delete + / fts_search / vector_search / get_scheduling / update_scheduling + / add_edge / get_edges / remove_edge / get_neighbors / cascade + delete). +9. No visibility filter clause is present in any Phase 2 method body. + `WHERE owner_user_id = ...`, `WHERE visibility = ...`, and + `shared_with_groups && ...` do not appear anywhere in + `crates/vestige-core/src/storage/postgres/`. +10. `cargo sqlx prepare` was the last command run before commit; the + diff includes `.sqlx/` changes if any query changed. diff --git a/docs/plans/0002e-hybrid-search.md b/docs/plans/0002e-hybrid-search.md new file mode 100644 index 0000000..1f45174 --- /dev/null +++ b/docs/plans/0002e-hybrid-search.md @@ -0,0 +1,825 @@ +# Phase 2 Sub-Plan 0002e -- Hybrid RRF Search + +**Status**: Ready +**Depends on**: +- `0002a-skeleton-and-feature-gate.md` (the `postgres-backend` feature flag + exists and `PgMemoryStore` compiles with `todo!()` bodies). +- `0002b-pool-and-config.md` (a working `PgPool` reaches the backend). +- `0002c-migrations.md` (migration `0001_init` has created the `knowledge_nodes` + table with the D7 columns -- `owner_user_id`, `visibility`, + `shared_with_groups` -- and the D8 column `codebase`; migration `0002_hnsw` + has built the HNSW index). +- `0002d-store-impl-bodies.md` (real CRUD bodies exist so the integration + tests below can seed data through the trait surface rather than raw SQL). + +This sub-plan covers master plan 0002 deliverable D5: the hybrid RRF search +query implementation in `crates/vestige-core/src/storage/postgres/search.rs`, +plus the `search`, `fts_search`, and `vector_search` method bodies in +`crates/vestige-core/src/storage/postgres/mod.rs` that delegate into it. + +--- + +## Context + +This is one of the more performance-sensitive sub-plans in Phase 2. Every +search call from the cognitive engine -- the 7-stage retrieval pipeline, +`session_context`, `predict`, `deep_reference`, the dashboard -- bottoms out +in `MemoryStore::search`. The Postgres backend has to keep up with the +existing SQLite hybrid path, which combines BM25 over FTS5 with USearch HNSW +in two separate round trips and fuses the rankings in Rust. + +The shape of the win on Postgres is that both branches and the fusion run +inside one statement. The planner sees both CTEs together, the round trip is +single, and the rerank stage runs over a cleanly overfetched candidate set. + +Latency targets live in `0002h-testing-and-benches.md`. This sub-plan is +responsible for producing a correct, schema-stable query that the benches +can drive against. Do not optimise here; correctness and structure first. + +Master plan 0002 D5 (around lines 522-628 of +`docs/plans/0002-phase-2-postgres-backend.md`) sketches the SQL. That +sketch is the starting point, not the finished product. The schema after +the D7 and D8 amendments has more columns than the sketch enumerates, and +the SQLite `search` method (around line 6503 of +`crates/vestige-core/src/storage/sqlite.rs` in the Phase 1 worktree) +documents the semantics this implementation must stay compatible with: + +- Empty `query.limit` defaults to 10. +- `query.text == Some("")` is treated as no text query (degrade to vector). +- `query.embedding == None` is treated as no vector query (degrade to FTS). +- Both empty returns `Ok(vec![])`; not an error. +- The `MemoryRecord` in each `SearchResult` must be populated with all + fields the trait promises, including `domains` and `domain_scores` (Phase + 4 will fill these in; Phase 2 returns the stored values, which may be + empty arrays / empty objects). + +--- + +## Constants + +```rust +/// Reciprocal Rank Fusion smoothing constant from Cormack, Clarke and Buettcher +/// 2009 ("Reciprocal Rank Fusion outperforms Condorcet and individual rank +/// learning methods"). 60 is the canonical default and is robust across most +/// fusion regimes. Do not tune this without a paper-citation-grade reason. +const RRF_K: i32 = 60; + +/// Each branch (FTS, vector) is allowed to return OVERFETCH_MULT x final_limit +/// rows before fusion. Three matches the Phase 1 SQLite overfetch and gives +/// the fusion enough candidates to recover from any single branch's bad +/// recall on a given query. +const OVERFETCH_MULT: i64 = 3; +``` + +These live at module scope in +`crates/vestige-core/src/storage/postgres/search.rs`. They are `pub(crate)` +only if `0002h-testing-and-benches.md` needs to reference them from the +integration tests; otherwise private. + +--- + +## Public API + +```rust +#![cfg(feature = "postgres-backend")] + +use pgvector::Vector; +use sqlx::PgPool; + +use crate::storage::memory_store::{ + MemoryStoreResult, SearchQuery, SearchResult, +}; + +/// Hybrid RRF search over Postgres FTS and pgvector cosine distance. +/// +/// Branch behavior: +/// - empty text + null embedding -> Ok(vec![]) +/// - empty text + Some(embedding) -> pure vector search (FTS CTE returns +/// zero rows; fusion equals the vector +/// branch) +/// - Some(text) + null embedding -> pure FTS search +/// - Some(text) + Some(embedding) -> full RRF fusion +/// +/// `query.limit == 0` is treated as 10 (matches the SQLite default). +pub(crate) async fn rrf_search( + pool: &PgPool, + query: &SearchQuery, +) -> MemoryStoreResult>; + +/// FTS-only convenience search. Equivalent to calling `rrf_search` with +/// `query.embedding = None`, but uses a dedicated single-branch query that +/// avoids the FULL OUTER JOIN and the params CTE; faster by one planner pass +/// per call. +pub(crate) async fn fts_only( + pool: &PgPool, + text: &str, + limit: usize, +) -> MemoryStoreResult>; + +/// Vector-only convenience search. Dedicated single-branch query for the same +/// latency reason as `fts_only`. +pub(crate) async fn vector_only( + pool: &PgPool, + embedding: &[f32], + limit: usize, +) -> MemoryStoreResult>; +``` + +### Parameter handling + +In `rrf_search`: + +```rust +let final_limit: i32 = if query.limit == 0 { 10 } else { query.limit as i32 }; +let overfetch: i32 = (final_limit as i64 * OVERFETCH_MULT) + .min(i32::MAX as i64) as i32; + +let q_text: &str = query.text.as_deref().unwrap_or(""); +let q_vec: Option = query.embedding.as_ref() + .map(|v| Vector::from(v.clone())); + +let dom_filter: Option<&[String]> = query.domains.as_deref(); +let nt_filter: Option<&[String]> = query.node_types.as_deref(); +let tag_filter: Option<&[String]> = query.tags.as_deref(); + +let min_retr: Option = query.min_retrievability; +``` + +Both branches empty -- `q_text` is empty and `q_vec` is `None` -- returns +`Ok(vec![])` without hitting the database. The SQLite backend has the same +behavior and tests rely on it. + +```rust +if q_text.is_empty() && q_vec.is_none() { + return Ok(Vec::new()); +} +``` + +### `search` method body in `postgres/mod.rs` + +```rust +#[async_trait::async_trait] // or trait_variant after the Phase 1 amendment +impl MemoryStore for PgMemoryStore { + async fn search(&self, query: &SearchQuery) + -> MemoryStoreResult> + { + crate::storage::postgres::search::rrf_search(&self.pool, query).await + } + + async fn fts_search(&self, text: &str, limit: usize) + -> MemoryStoreResult> + { + crate::storage::postgres::search::fts_only(&self.pool, text, limit) + .await + } + + async fn vector_search(&self, embedding: &[f32], limit: usize) + -> MemoryStoreResult> + { + crate::storage::postgres::search::vector_only(&self.pool, embedding, limit) + .await + } +} +``` + +Everything below specifies the inside of those three free functions. + +--- + +## SQL: the hybrid RRF query + +The query is built as one `&'static str` (or `OnceCell`; see "Use +of sqlx::query!" below) and reused. Bound parameters are kept to seven +through a `params` CTE that the rest of the query references by name -- +this keeps the SQL readable and stops the bound-parameter count growing +with each filter clause. + +Bound parameters: + +- `$1`: text query (TEXT, may be empty) +- `$2`: embedding (pgvector::Vector, may be NULL) +- `$3`: overfetch limit per branch (INT) +- `$4`: final limit (INT) +- `$5`: domain filter (TEXT[] or NULL) +- `$6`: node_type filter (TEXT[] or NULL) +- `$7`: tag filter (TEXT[] or NULL) + +If `min_retrievability.is_some()` the outer SELECT adds a JOIN on +`scheduling` and a WHERE clause; that path uses a different prepared +statement (see "min_retrievability filter" below) so the simple-path query +stays free of the join. + +```sql +WITH params AS ( + SELECT + $1::text AS q_text, + $2::vector AS q_vec, + $3::int AS overfetch, + $4::int AS final_limit, + $5::text[] AS dom_filter, + $6::text[] AS nt_filter, + $7::text[] AS tag_filter +), +fts AS ( + SELECT + m.id, + ts_rank_cd( + m.search_vec, + websearch_to_tsquery('english', p.q_text) + ) AS score, + ROW_NUMBER() OVER ( + ORDER BY ts_rank_cd( + m.search_vec, + websearch_to_tsquery('english', p.q_text) + ) DESC + ) AS rank + FROM knowledge_nodes m + CROSS JOIN params p + WHERE p.q_text <> '' + AND m.search_vec @@ websearch_to_tsquery('english', p.q_text) + AND (p.dom_filter IS NULL OR m.domains && p.dom_filter) + AND (p.nt_filter IS NULL OR m.node_type = ANY(p.nt_filter)) + AND (p.tag_filter IS NULL OR m.tags && p.tag_filter) + ORDER BY score DESC + LIMIT (SELECT overfetch FROM params) +), +vec AS ( + SELECT + m.id, + 1.0 - (m.embedding <=> p.q_vec) AS score, + ROW_NUMBER() OVER ( + ORDER BY m.embedding <=> p.q_vec + ) AS rank + FROM knowledge_nodes m + CROSS JOIN params p + WHERE m.embedding IS NOT NULL + AND p.q_vec IS NOT NULL + AND (p.dom_filter IS NULL OR m.domains && p.dom_filter) + AND (p.nt_filter IS NULL OR m.node_type = ANY(p.nt_filter)) + AND (p.tag_filter IS NULL OR m.tags && p.tag_filter) + ORDER BY m.embedding <=> p.q_vec + LIMIT (SELECT overfetch FROM params) +), +fused AS ( + SELECT + COALESCE(f.id, v.id) AS id, + COALESCE(1.0 / (60 + f.rank), 0.0) + + COALESCE(1.0 / (60 + v.rank), 0.0) AS rrf_score, + f.score AS fts_score, + v.score AS vector_score + FROM fts f + FULL OUTER JOIN vec v ON f.id = v.id +) +SELECT + m.id AS "id!: uuid::Uuid", + m.owner_user_id AS "owner_user_id!: uuid::Uuid", + m.visibility AS "visibility!: String", + m.shared_with_groups AS "shared_with_groups!: Vec", + m.codebase AS "codebase: String", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.content AS "content!: String", + m.node_type AS "node_type!: String", + m.tags AS "tags!: Vec", + m.embedding AS "embedding: pgvector::Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: chrono::DateTime", + m.updated_at AS "updated_at!: chrono::DateTime", + fused.rrf_score AS "rrf_score!: f64", + fused.fts_score AS "fts_score: f64", + fused.vector_score AS "vector_score: f64" +FROM fused +JOIN knowledge_nodes m ON m.id = fused.id +ORDER BY fused.rrf_score DESC +LIMIT (SELECT final_limit FROM params); +``` + +Notes on the SELECT column list. The D7 columns (`owner_user_id`, +`visibility`, `shared_with_groups`) and the D8 column (`codebase`) are +selected even though Phase 2 does not filter on them yet, so: + +1. The `MemoryRecord` returned to the trait can be populated with the + stored values from day one. Phase 3 will start writing real + `owner_user_id` / `visibility` values; Phase 2 always writes the + single-user defaults (`'00000000-...-0001'`, `'private'`, `'{}'`). The + `MemoryRecord` returned in Phase 2 simply carries those defaults. +2. The schema-drift integration tests (see "Verification") catch the case + where someone adds a NOT NULL column to `knowledge_nodes` without updating + this query. + +Notes on the body: + +- `CROSS JOIN params p` is used instead of the master-plan sketch's + `FROM knowledge_nodes m, params p`. Same plan, clearer intent. +- The `ORDER BY ... LIMIT` inside each branch CTE is there so the planner + can stop early once it has `overfetch` rows; without it the LIMIT is + applied after a full sort over all matches. +- `1.0 - (m.embedding <=> p.q_vec)` converts pgvector's cosine *distance* + to cosine *similarity* in [0, 1] for the `vector_score` output. RRF + itself does not need the similarity -- it uses ranks -- but the trait + surface exposes `vector_score: Option` for caller introspection. +- `RRF_K = 60` is inlined as `60` in the SQL string. A `const` formatter + feels tidier but `60` is a literature constant; spell it out and leave a + comment in the Rust source: `// 60 == RRF_K (Cormack 2009)`. +- `FULL OUTER JOIN` is required: a row that the FTS branch finds and the + vector branch does not must still appear in `fused`, and vice versa. +- `COALESCE(..., 0.0)` on each `1.0 / (60 + rank)` term handles the + no-match-from-this-branch case. The fusion score for a row that only the + FTS branch ranks is `1/(60 + f.rank)` exactly. +- `m.search_vec` is the generated `tsvector` column created in migration + `0001_init` (see D4 of the master plan). + +--- + +## Result row mapping + +`sqlx::query_as::<_, SearchRow>` reads each row into a private struct that +owns the column types exactly as they come back from Postgres. The struct +is converted into a `SearchResult` after fetch. + +```rust +#[derive(sqlx::FromRow)] +struct SearchRow { + id: uuid::Uuid, + owner_user_id: uuid::Uuid, + visibility: String, + shared_with_groups: Vec, + codebase: Option, + domains: Vec, + domain_scores: serde_json::Value, + content: String, + node_type: String, + tags: Vec, + embedding: Option, + metadata: serde_json::Value, + created_at: chrono::DateTime, + updated_at: chrono::DateTime, + rrf_score: f64, + fts_score: Option, + vector_score: Option, +} + +impl SearchRow { + fn into_result(self) -> SearchResult { + use crate::storage::memory_store::MemoryRecord; + use std::collections::HashMap; + + // domain_scores is JSONB; the column always exists, but may be the + // empty object {} when Phase 4 has not classified this memory yet. + let domain_scores: HashMap = + serde_json::from_value(self.domain_scores).unwrap_or_default(); + + let record = MemoryRecord { + id: self.id, + domains: self.domains, + domain_scores, + content: self.content, + node_type: self.node_type, + tags: self.tags, + // pgvector::Vector -> Vec + embedding: self.embedding.map(|v| v.to_vec()), + created_at: self.created_at, + updated_at: self.updated_at, + metadata: self.metadata, + // owner_user_id / visibility / shared_with_groups / codebase + // do not appear on MemoryRecord yet. Phase 3 will decide whether + // to extend MemoryRecord or surface them via a side channel. + // For Phase 2 they are read but discarded here. + }; + + SearchResult { + record, + score: self.rrf_score, + fts_score: self.fts_score, + vector_score: self.vector_score, + } + } +} +``` + +Type mapping summary: + +| SQL type | Rust type | Notes | +|-------------------|--------------------------------------|------------------------------------------------| +| UUID | `uuid::Uuid` | requires sqlx `uuid` feature | +| TEXT | `String` | | +| TEXT NULL | `Option` | used for `codebase` | +| TEXT[] | `Vec` | for `tags`, `domains` | +| UUID[] | `Vec` | for `shared_with_groups` | +| JSONB | `serde_json::Value` | for `metadata`, `domain_scores` | +| TIMESTAMPTZ | `chrono::DateTime` | requires sqlx `chrono` feature | +| VECTOR(N) NULL | `Option` | `.map(|v| v.to_vec())` to `Option>` | +| FLOAT8 | `f64` | | +| FLOAT8 NULL | `Option` | for `fts_score`, `vector_score` | + +If `MemoryRecord` is extended in Phase 3 to carry `owner_user_id`, +`visibility`, `shared_with_groups`, and `codebase`, the conversion above +gets four more fields. Phase 2 reads them so the integration tests can +assert on them via SQL, but the trait surface does not expose them yet. + +--- + +## `fts_only` and `vector_only` -- dedicated single-branch queries + +The master plan offers two options for the convenience methods: reuse +`rrf_search` with one branch nulled, or write dedicated queries. The +dedicated queries win: + +- One CTE instead of three. Planner picks the obvious plan. +- No FULL OUTER JOIN. +- No `params` indirection -- bound parameters used directly. +- The output `score` is the branch's native score (BM25-ish `ts_rank_cd` / + cosine similarity), not an RRF fusion score over one branch. Callers of + `fts_search` and `vector_search` get an intuitive score back. + +### `fts_only` + +Bound parameters: + +- `$1`: text query (TEXT, must be non-empty; the caller guards `text.is_empty()`) +- `$2`: limit (INT) + +```sql +SELECT + m.id AS "id!: uuid::Uuid", + m.owner_user_id AS "owner_user_id!: uuid::Uuid", + m.visibility AS "visibility!: String", + m.shared_with_groups AS "shared_with_groups!: Vec", + m.codebase AS "codebase: String", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.content AS "content!: String", + m.node_type AS "node_type!: String", + m.tags AS "tags!: Vec", + m.embedding AS "embedding: pgvector::Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: chrono::DateTime", + m.updated_at AS "updated_at!: chrono::DateTime", + ts_rank_cd(m.search_vec, websearch_to_tsquery('english', $1)) + AS "fts_score!: f64" +FROM knowledge_nodes m +WHERE m.search_vec @@ websearch_to_tsquery('english', $1) +ORDER BY ts_rank_cd(m.search_vec, websearch_to_tsquery('english', $1)) DESC +LIMIT $2; +``` + +The Rust caller maps each row to a `SearchResult` with: + +```rust +SearchResult { + record, + score: fts_score, + fts_score: Some(fts_score), + vector_score: None, +} +``` + +If `text.is_empty()` the caller returns `Ok(Vec::new())` before hitting +the database. `websearch_to_tsquery('english', '')` returns an empty +tsquery that matches nothing; the round-trip is wasted work otherwise. + +### `vector_only` + +Bound parameters: + +- `$1`: embedding (pgvector::Vector) +- `$2`: limit (INT) + +```sql +SELECT + m.id AS "id!: uuid::Uuid", + m.owner_user_id AS "owner_user_id!: uuid::Uuid", + m.visibility AS "visibility!: String", + m.shared_with_groups AS "shared_with_groups!: Vec", + m.codebase AS "codebase: String", + m.domains AS "domains!: Vec", + m.domain_scores AS "domain_scores!: serde_json::Value", + m.content AS "content!: String", + m.node_type AS "node_type!: String", + m.tags AS "tags!: Vec", + m.embedding AS "embedding: pgvector::Vector", + m.metadata AS "metadata!: serde_json::Value", + m.created_at AS "created_at!: chrono::DateTime", + m.updated_at AS "updated_at!: chrono::DateTime", + 1.0 - (m.embedding <=> $1) AS "vector_score!: f64" +FROM knowledge_nodes m +WHERE m.embedding IS NOT NULL +ORDER BY m.embedding <=> $1 +LIMIT $2; +``` + +The Rust caller maps each row to: + +```rust +SearchResult { + record, + score: vector_score, + fts_score: None, + vector_score: Some(vector_score), +} +``` + +Both convenience methods ignore `SearchQuery.domains` / `tags` / +`node_types` / `min_retrievability` -- they take `&str` and `&[f32]` +respectively, not a `SearchQuery`. Callers that want filters on a +single-branch search should call `search` with the other branch input +left at its degrade-to-zero default. + +--- + +## `min_retrievability` filter + +`SearchQuery::min_retrievability: Option` is applied as a final +filter after fusion by joining on the `scheduling` table: + +```sql +-- with-min-retrievability variant: identical CTEs to the base query, only +-- the final SELECT changes. +SELECT + ... (same column list as the base query) ... +FROM fused +JOIN knowledge_nodes m ON m.id = fused.id +JOIN scheduling s ON s.memory_id = m.id +WHERE s.retrievability >= $8 +ORDER BY fused.rrf_score DESC +LIMIT (SELECT final_limit FROM params); +``` + +This is a separate prepared statement -- the eight-parameter variant -- +held alongside the seven-parameter base. The Rust dispatch: + +```rust +if let Some(min_r) = query.min_retrievability { + sqlx::query_as::<_, SearchRow>(QUERY_WITH_MIN_R) + .bind(q_text) + .bind(q_vec) + .bind(overfetch) + .bind(final_limit) + .bind(dom_filter) + .bind(nt_filter) + .bind(tag_filter) + .bind(min_r) + .fetch_all(pool).await? +} else { + sqlx::query_as::<_, SearchRow>(QUERY_BASE) + .bind(q_text) + .bind(q_vec) + .bind(overfetch) + .bind(final_limit) + .bind(dom_filter) + .bind(nt_filter) + .bind(tag_filter) + .fetch_all(pool).await? +} +``` + +Why not unconditionally join: the `scheduling` join is expensive enough on +a large `knowledge_nodes` table that adding it to every search call regresses the +common path. `min_retrievability` is set by the cognitive engine's +accessibility filter and is `None` in most direct callers. + +The same two-variant pattern repeats for `fts_only` and `vector_only`; in +practice callers of those methods rarely set `min_retrievability` (it is +not part of their argument list), so only the base variant is needed +unless the trait surface grows. + +--- + +## Domain / tag / node_type filters + +Each filter is expressed as a NULL-conditional clause inside both branch +CTEs, written using PostgreSQL array operators: + +```sql +AND (p.dom_filter IS NULL OR m.domains && p.dom_filter) +AND (p.nt_filter IS NULL OR m.node_type = ANY(p.nt_filter)) +AND (p.tag_filter IS NULL OR m.tags && p.tag_filter) +``` + +- `&&` is the PostgreSQL "arrays overlap" operator. Matches if any + element in `m.domains` is in the filter array. Index-friendly with a + GIN index on `m.domains` (created in `0001_init`). +- `= ANY(...)` matches `m.node_type` (a scalar) against any element of + the filter array. Index-friendly with a B-tree on `m.node_type`. +- `&&` is used again on `m.tags` (a `TEXT[]`). + +The NULL-conditional form is critical: when the filter parameter is +`NULL`, the clause short-circuits to `TRUE` and contributes nothing to +the WHERE. This keeps a single query reusable across "no filter" and +"filter set" cases without rewriting SQL. + +When the Rust caller passes `None` for a filter, sqlx binds it as `NULL` +of the column type (`text[]`). The cast `$5::text[]` in the `params` CTE +is what tells sqlx the binding type. + +The master plan's draft has each filter clause duplicated across both +branch CTEs. That duplication is correct -- the planner cannot push a +WHERE clause across a FULL OUTER JOIN into both sides automatically; we +do it manually. + +--- + +## Empty-string text query handling + +The base query guards the FTS branch with `WHERE p.q_text <> ''`. + +`websearch_to_tsquery('english', '')` returns an empty tsquery. An empty +tsquery has no lexemes and matches no document; the `@@` operator returns +false for every row. Without the guard, the FTS branch would still run -- +sequential scan, tokenisation per row, comparison -- and return zero +rows. The guard short-circuits at planning time. + +The guard does not affect the FULL OUTER JOIN: when the FTS branch +returns zero rows, the join degenerates to "every row that the vector +branch returned, with `f.id IS NULL` and `f.rank IS NULL`". The +`COALESCE(1.0 / (60 + f.rank), 0.0)` then evaluates to `0.0`, and the +fused score reduces to the vector branch's RRF term alone. This is the +"pure vector search" degrade path. + +Symmetrically, the vector branch guards itself with +`WHERE m.embedding IS NOT NULL AND p.q_vec IS NOT NULL`, which gives the +"pure FTS search" degrade path when the caller passes no embedding. + +The both-empty case (`q_text == ''` and `q_vec IS NULL`) is intercepted +in Rust before the query runs and returns `Ok(vec![])`. Returning empty +rather than error matches the SQLite behavior and is what the Phase 1 +ingest pipeline relies on for "no signal, no results" fallback. + +--- + +## Use of `sqlx::query!` versus `sqlx::query_as` + +`sqlx::query!` and `sqlx::query_as!` are compile-time-checked: the SQL is +sent to a live Postgres at build time, the result schema is validated, and +the generated Rust struct fields are derived. That checking is the +default for every other query in `0002d-store-impl-bodies.md`. + +For the RRF query, the macro path is impractical for two reasons: + +1. **Two structurally different queries** -- the base (seven parameters, + no `scheduling` join) and the `min_retrievability` variant (eight + parameters, with the join). The macro would force two macro + invocations, each producing its own anonymous result struct, and the + result types would not unify. Manual `From` impls would be needed in + both directions. +2. **The dedicated `fts_only` and `vector_only` queries have a different + output column set** (`fts_score!` instead of `rrf_score! + fts_score? + + vector_score?`). Three macro invocations, three structs, three + conversion helpers. + +The chosen pattern is `sqlx::query_as::<_, SearchRow>(SQL_CONST)` with a +single `SearchRow` struct that owns the column types and a single +`SearchRow::into_result` helper. The SQL is held in module-scope `&'static +str` constants: + +```rust +const QUERY_BASE: &str = include_str!("search.rrf.sql"); +const QUERY_WITH_MIN_R: &str = include_str!("search.rrf.min_retr.sql"); +const QUERY_FTS_ONLY: &str = include_str!("search.fts.sql"); +const QUERY_VECTOR_ONLY: &str = include_str!("search.vector.sql"); +``` + +`include_str!` keeps the SQL out of the Rust source. The four `.sql` +files live next to `search.rs` in +`crates/vestige-core/src/storage/postgres/`. + +The cost: schema drift (someone renames `m.codebase` to `m.repo_name`) +will not break the build. The integration tests in "Verification" below +are the safety net. This is a deliberate trade -- it is the one sub-plan +in Phase 2 where runtime flexibility beats compile-time checking. + +If a future contributor wants compile-time checking back for the simple +case, the right move is to introduce a `#[cfg(test)]`-only macro-checked +variant of `QUERY_BASE` and assert at test build time that the macro +agrees with the string. That belongs in `0002h-testing-and-benches.md` if +anywhere. + +--- + +## Verification + +Integration tests live in +`crates/vestige-core/tests/postgres_search.rs`, gated by +`#[cfg(feature = "postgres-backend")]` and `#[ignore]` by default (the +test runner CI workflow in `0002h-testing-and-benches.md` runs them with +`--ignored` against a live Postgres). + +Common harness for every test: + +1. Spin up Postgres via `sqlx::PgPool::connect` against the test URL. +2. Run `sqlx::migrate!("./migrations/postgres").run(&pool)` to bring the + schema up. +3. Register a deterministic test embedder via `register_model` so + `embedding` columns can be written. +4. Seed 50 mixed memories through `MemoryStore::insert` -- mixed + `node_type` (`fact`, `concept`, `event`, `decision`), mixed `tags` + (`rust`, `postgres`, `search`, `dream`, `bug-fix`), mixed `codebase`, + embeddings drawn from three small clusters so vector recall has + structure to find. + +Test cases: + +**T1. Full RRF returns the seeded target.** +Insert a known memory with `content = "FSRS-6 spaced repetition cadence"` +and an embedding from cluster A. Query with +`text = Some("FSRS spaced repetition")` and an embedding near cluster A. +Assert the target memory is in the top 3 of the returned `SearchResult`s +and that both `fts_score` and `vector_score` are `Some` for it. + +**T2. Pure FTS degrade.** +Same target as T1. Query with `text = Some("FSRS spaced repetition")` and +`embedding = None`. Assert the target appears, all results have +`vector_score == None`, `fts_score == Some(_)`, and `score` equals the +fused RRF score (which collapses to one branch's `1.0/(60 + rank)`). + +**T3. Pure vector degrade.** +Same target as T1. Query with `text = Some("")` and +`embedding = Some(cluster_A_vector)`. Assert the target appears, all +results have `fts_score == None`, `vector_score == Some(_)`. + +**T4. Both empty returns `Ok(vec![])`.** +Query with `text = Some("")` and `embedding = None`. Assert exactly an +empty result vector and that no SQL was executed (assert via a +`sqlx::PgPool` query-count handle if convenient; otherwise document that +the short-circuit lives in Rust). + +**T5. `domains` filter.** +Insert one memory with `domains = vec!["domain-x"]` and 49 others without +it. Query with `domains = Some(vec!["domain-x"])` and a matching text. +Assert exactly one result is returned and it is the seeded memory. + +**T6. `tags` filter.** +Same pattern as T5 with `tags = Some(vec!["bug-fix"])`. + +**T7. `node_types` filter.** +Same pattern as T5 with `node_types = Some(vec!["decision"])`. + +**T8. `min_retrievability` filter.** +Seed two memories with the same content + embedding. Write +`scheduling` rows so that one has `retrievability = 0.9` and the other +`0.1`. Query with `min_retrievability = Some(0.5)`. Assert exactly the +high-retrievability memory is returned. + +**T9. `query.limit == 0` defaults to 10.** +Seed 30 matching memories. Query with `limit = 0`. Assert the result +contains exactly 10 entries. + +**T10. `fts_only` and `vector_only` parity.** +For the same target memory, call `fts_only` and `vector_only` directly +and compare against `search` with the corresponding branch zeroed. The +top-1 result must match by id; the scores need only be of the same sign +and magnitude (not bit-identical, because RRF fusion changes the +absolute score). + +**T11. Schema-drift canary.** +Run the base query against an empty `knowledge_nodes` table and `fetch_all` +into `Vec`. Any added NOT NULL column on `knowledge_nodes` that is +not in the SELECT will fail the test at the `try_get` boundary with a +clear error. This is the test that compensates for not using +`sqlx::query!`. + +**T12. Hostile inputs.** +Query with `text = Some("'; DROP TABLE knowledge_nodes; --")` and a normal +embedding. Assert no panic, results returned cleanly, `knowledge_nodes` table +still present. This is symbolic; `websearch_to_tsquery` is parameter- +bound and SQL injection is not actually possible, but the test is cheap +and the assertion is real. + +--- + +## Acceptance criteria + +A reviewer of the implementation PR should be able to confirm: + +1. `crates/vestige-core/src/storage/postgres/search.rs` exists and is + compiled only when `feature = "postgres-backend"` is on. +2. The four `.sql` files (`search.rrf.sql`, + `search.rrf.min_retr.sql`, `search.fts.sql`, `search.vector.sql`) + exist in the same directory and are `include_str!`-ed into module- + scope `&'static str` constants. +3. `RRF_K = 60` and `OVERFETCH_MULT = 3` are defined as constants at + module scope with the Cormack 2009 citation in a comment. +4. The seven-parameter base query is one statement and uses a `params` + CTE; the eight-parameter `min_retrievability` variant adds exactly + one JOIN and one WHERE clause on top of the base. +5. Empty text degrades to pure vector; null embedding degrades to pure + FTS; both empty short-circuits to `Ok(vec![])` in Rust before the + query runs. +6. The SELECT column list in every query includes `owner_user_id`, + `visibility`, `shared_with_groups`, and `codebase` even though Phase 2 + does not filter on them. +7. `SearchRow::into_result` populates a `MemoryRecord` with every field + the trait requires, including `domains` and `domain_scores` decoded + from JSONB. +8. `PgMemoryStore::search`, `PgMemoryStore::fts_search`, and + `PgMemoryStore::vector_search` each delegate to the corresponding + free function with one line of body. +9. All twelve integration tests (`T1` through `T12`) pass against a live + Postgres with the `0001_init` + `0002_hnsw` migrations applied. +10. `cargo build -p vestige-core` succeeds with + `--features postgres-backend` and with the feature off. +11. `cargo clippy -p vestige-core --features postgres-backend -- -D warnings` + is clean. + +When all eleven are true, this sub-plan is done and +`0002f-migrate-cli.md` is unblocked. diff --git a/docs/plans/0002f-migrate-cli.md b/docs/plans/0002f-migrate-cli.md new file mode 100644 index 0000000..457de70 --- /dev/null +++ b/docs/plans/0002f-migrate-cli.md @@ -0,0 +1,1045 @@ +# Phase 2 Sub-Plan 0002f -- SQLite-to-Postgres Migrate CLI + +**Status**: Ready +**Depends on**: +- `0002a-skeleton-and-feature-gate.md` (the `postgres-backend` Cargo feature + and the `crates/vestige-core/src/storage/postgres/` module skeleton). +- `0002b-pool-and-config.md` (`PgPool` construction and `PostgresConfig`). +- `0002c-migrations.md` (the `postgres/migrations/0001_init.up.sql` schema, + including the D7 tenancy columns/tables and the D8 `codebase` column). +- `0002d-store-impl-bodies.md` (real bodies for `PgMemoryStore` trait methods: + `insert`, `register_model`, `add_edge`, `update_scheduling`, etc.; and the + matching source-side reader bodies on `SqliteMemoryStore`, in particular a + windowed-stream API ordered by `(created_at, id)`). + +This sub-plan covers Phase 2 master-plan deliverables D8 (the streaming copy +in `crates/vestige-core/src/storage/postgres/migrate_cli.rs`) and D10 (the +`vestige migrate copy ...` clap subcommand in +`crates/vestige-mcp/src/bin/cli.rs`). Sub-plan `0002g-reembed.md` covers the +`vestige migrate reembed ...` subcommand body; this sub-plan only declares the +`Reembed` clap variant alongside `Copy` so the subcommand layout is final. + +The success criterion is: + +``` +vestige migrate copy --from sqlite --to postgres \ + --sqlite-path ~/.vestige/vestige.db \ + --postgres-url postgresql://localhost/vestige +``` + +streams every row from a Phase 1 SQLite database into a fresh (or partially +populated) Phase 2 Postgres database. Re-running the same command is a no-op +on already-present rows. A `--dry-run` flag prints per-table counts without +writing anything. + +--- + +## Context + +ADR 0002 D2 settled that `PgMemoryStore::connect` mirrors +`SqliteMemoryStore::new`: no `Embedder` in the constructor; the model +signature is stamped by a separate call to `register_model`. The migrator +inherits this symmetry. It opens both backends, validates that the source's +`embedding_model` registry agrees with the destination's (or with the +embedder the user supplied for the destination), and then streams rows. + +ADR 0002 D7 reserved multi-tenancy columns on `knowledge_nodes` (`owner_user_id`, +`visibility`, `shared_with_groups`) and three tables (`users`, `groups`, +`group_memberships`). Phase 2 single-user defaults are the bootstrap row +`'00000000-0000-0000-0000-000000000001'` (`'local'`), `visibility = 'private'`, +empty `shared_with_groups`. The migrator preserves whatever values the source +SQLite holds; it does NOT rewrite owner_user_id from real values to the +bootstrap user. If a Phase 3-aware source has real user rows, those are +copied first (step 5 below) and the foreign key in `knowledge_nodes.owner_user_id` +resolves to the same UUID on the destination. + +ADR 0002 D8 promoted `codebase` to a first-class `TEXT` column. The migrator +reads it as a column on the source side (the Phase 1 amendment's V15 SQLite +migration ensures the column exists; for pre-V15 SQLite the migrator must +detect and fall back to extracting from `metadata->>'codebase'`, see "Source +schema variants" below). + +The Phase 1 `SqliteMemoryStore` is the source backend. `0002d-store-impl-bodies.md` +extends it (and the trait) with a windowed reader ordered by `(created_at, id)` +so the migrator can stream rows in deterministic batches without holding the +full result set in RAM. The migrator assumes that reader exists and produces +`MemoryRecord` instances with all D7+D8 columns populated. + +--- + +## File layout + +``` +crates/vestige-core/src/storage/postgres/migrate_cli.rs -- D8 body +crates/vestige-mcp/src/bin/cli.rs -- D10 clap wiring +tests/phase_2/migrate_test.rs -- integration test +``` + +The migrator lives behind `#[cfg(feature = "postgres-backend")]`. The +`Migrate` clap variant in the CLI is similarly gated. Without the feature, +`vestige` builds and runs exactly as in Phase 1 -- the `migrate` subcommand +simply does not exist. + +--- + +## Plan struct + +```rust +#![cfg(feature = "postgres-backend")] + +use std::path::PathBuf; +use std::sync::Arc; + +use uuid::Uuid; + +use crate::embedder::Embedder; +use crate::storage::memory_store::MemoryStoreError; + +#[derive(Debug, Clone)] +pub struct SqliteToPostgresPlan { + /// Filesystem path to the source SQLite database. Opened read-only. + pub sqlite_path: PathBuf, + + /// libpq-style URL for the destination Postgres database. + pub postgres_url: String, + + /// sqlx pool size for the destination. Default 4. The migrator is + /// single-writer per table for ordering reasons; extra connections are + /// only used for the embedding-model registry probe and for the dry-run + /// COUNT queries that run in parallel with the row scan. + pub max_connections: u32, + + /// Number of rows per Postgres transaction. Default 500. Larger batches + /// reduce commit overhead but increase the amount of work a crash + /// re-runs. + pub batch_size: usize, + + /// If true, count rows per table and emit a report without writing + /// anything to Postgres. + pub dry_run: bool, +} + +impl Default for SqliteToPostgresPlan { + fn default() -> Self { + Self { + sqlite_path: PathBuf::new(), + postgres_url: String::new(), + max_connections: 4, + batch_size: 500, + dry_run: false, + } + } +} +``` + +The struct is public so a future programmatic driver (Rhai script, hero +service, in-process test harness) can call `run_sqlite_to_postgres` without +touching clap. + +--- + +## Report struct + +```rust +#[derive(Debug, Default)] +pub struct MigrationReport { + pub memories_copied: u64, + pub scheduling_rows: u64, + pub edges_copied: u64, + pub review_events_copied: u64, + pub domains_copied: u64, + pub users_copied: u64, + pub groups_copied: u64, + pub group_memberships_copied: u64, + + /// Per-row failures that did not abort the migrator. Each entry pairs + /// the source row id (where derivable) with the error that caused it to + /// be skipped. Rows whose UUID cannot be parsed are reported with + /// `Uuid::nil()` and a descriptive `MemoryStoreError::InvalidInput`. + pub errors: Vec<(Uuid, MemoryStoreError)>, +} +``` + +`errors.is_empty()` is the "clean migration" check. The CLI prints +`errors.len()` at the end and exits non-zero if it is positive. + +Counts are the number of rows the migrator either inserted or skipped due to +ON CONFLICT. They reflect what the source presented, not what the destination +ended up with -- that distinction matters for re-runs: a re-run of a finished +migration reports the same counts but writes zero new rows. + +--- + +## Driver fn + +```rust +pub async fn run_sqlite_to_postgres( + plan: SqliteToPostgresPlan, + embedder: Arc, +) -> MemoryStoreResult; +``` + +Algorithm, step by step: + +### Step 1. Open source SQLite read-only + +Build a SQLite URL with `?mode=ro` so the migrator cannot mutate the source +even by accident: + +```rust +let src_url = format!( + "sqlite://{}?mode=ro", + plan.sqlite_path.display(), +); +let src = SqliteMemoryStore::open_url(&src_url).await?; +``` + +`SqliteMemoryStore::open_url` is added by `0002d-store-impl-bodies.md` as a +small wrapper over the existing `new` that accepts a fully-formed URL. If the +file does not exist, `MemoryStoreError::Init` propagates. + +The source store still runs its own startup-time migrations in `?mode=ro`? +No -- read-only mode rejects writes. The migrator therefore opens the source +twice if the live source DB is older than V15: once writable to bring its +schema forward to V15 (so the D7+D8 columns are present), then re-opens +read-only. Detection: query `user_version` on the source DB before opening +the read-only handle. If it is below V15 and `--allow-source-upgrade` is set, +open writable, run `SqliteMemoryStore::new` (which runs migrations), close, +and re-open read-only. If `--allow-source-upgrade` is not set, fail with a +clear error pointing at the flag. Default: not set; the user must opt in to +modifying their source. + +### Step 2. Embedding model registry compatibility check + +Read both registries: + +```rust +let src_sig = src.registered_model().await?; +let actual = embedder.model_signature(); // ModelSignature +``` + +If `src_sig` is `Some` and disagrees with `actual` (any of `name`, +`dimension`, `hash`), return: + +```rust +MemoryStoreError::ModelMismatch { + registered_name: src_sig.name, + registered_dim: src_sig.dimension, + registered_hash: src_sig.hash, + actual_name: actual.name, + actual_dim: actual.dimension, + actual_hash: actual.hash, +} +``` + +The CLI translates this into a message that mentions `0002g`'s `--reembed` +command as the recovery path. Do NOT silently re-encode here; that is a +separate concern with its own flag set, performance profile, and HNSW +rebuild. + +If `src_sig` is `None` (source never had an embedding model -- empty DB or +pre-Phase-1), use the actual embedder's signature for the destination +registry. Memory rows whose `embedding` column is NULL stay NULL on the +destination side. + +### Step 3. Open destination Postgres + +```rust +let dst = PgMemoryStore::connect(&plan.postgres_url, plan.max_connections).await?; +``` + +`PgMemoryStore::connect` (per `0002d-store-impl-bodies.md`) runs the +`sqlx::migrate!` macro internally, which idempotently applies `0001_init` +and `0002_hnsw`. Re-running the migrator against an already-initialised +destination is fine. + +Stamp the registry on the destination: + +```rust +let sig = src_sig.unwrap_or_else(|| embedder.model_signature()); +dst.register_model(&sig).await?; +``` + +`register_model` is idempotent in the Postgres backend: it upserts the single +registry row, and (per ADR 0002 D2) it runs the `ALTER TABLE knowledge_nodes +ALTER COLUMN embedding TYPE vector($N)` typmod stamp inside its body. The +ALTER is itself idempotent: pgvector accepts the same typmod twice as a no-op. + +### Step 4. Verify schema + +Not really a separate step -- `PgMemoryStore::connect` already calls +`sqlx::migrate!` and the `register_model` call already stamps the typmod. +Listed here for documentation: this is the point at which the destination is +known to be schema-correct for the source's embedding dimension. + +### Step 5. Copy `users`, `groups`, `group_memberships` first + +These tables exist for both pre-Phase-3 and Phase-3-aware sources because +ADR 0002 D7 reserved them in V15 of the SQLite schema. Phase 2 single-user +deployments have exactly one user row (`local`) and zero groups, but the +migrator does not assume that: it copies whatever is present. + +The bootstrap user `00000000-0000-0000-0000-000000000001` is inserted by +`0001_init.up.sql` on the destination. The source's bootstrap row collides +with the destination's; `ON CONFLICT (id) DO NOTHING` resolves the collision +silently. + +Pseudocode: + +```rust +let mut tx = dst.pool().begin().await?; +let mut report = MigrationReport::default(); + +for batch in src.stream_users(plan.batch_size).await? { + for u in batch? { + sqlx::query!( + "INSERT INTO users (id, handle, display_name, created_at, metadata) \ + VALUES ($1, $2, $3, $4, $5) \ + ON CONFLICT (id) DO NOTHING", + u.id, u.handle, u.display_name, u.created_at, u.metadata, + ).execute(&mut *tx).await?; + report.users_copied += 1; + } +} +tx.commit().await?; +``` + +Repeat the same shape for `groups` and `group_memberships`. The membership +table has a composite primary key `(user_id, group_id)`: + +```rust +"INSERT INTO group_memberships (user_id, group_id, role, joined_at) \ + VALUES ($1, $2, $3, $4) \ + ON CONFLICT (user_id, group_id) DO NOTHING", +``` + +The `stream_users` / `stream_groups` / `stream_memberships` reader methods on +`SqliteMemoryStore` are introduced by `0002d-store-impl-bodies.md`. They +return `BoxStream>>` to keep the migrator +backend-agnostic. + +If the source SQLite predates V15 -- the V15 migration is the one that +introduces these tables -- they simply do not exist. The reader detects +their absence at open time and returns an empty stream. See "Source schema +variants" below. + +### Step 6. Copy `knowledge_nodes` in batches + +Stream the source ordered by `(created_at, id)`. The cursor key is the +last-seen `(created_at, id)` pair; the reader uses keyset pagination so +restarts pick up where the previous run left off: + +```sql +SELECT ... +FROM knowledge_nodes +WHERE (created_at, id) > ($cursor_ts, $cursor_id) +ORDER BY created_at, id +LIMIT $batch_size +``` + +For each batch: + +```rust +let mut tx = dst.pool().begin().await?; +for record in batch { + // D7 + D8 columns are all on MemoryRecord by Phase 2. + let groups: Vec = record.shared_with_groups.clone(); + + let result = sqlx::query!( + "INSERT INTO knowledge_nodes ( \ + id, content, node_type, tags, embedding, \ + created_at, updated_at, metadata, \ + owner_user_id, visibility, shared_with_groups, \ + codebase, domains, domain_scores \ + ) VALUES ( \ + $1, $2, $3, $4, $5::vector, \ + $6, $7, $8, \ + $9, $10, $11, \ + $12, $13, $14::jsonb \ + ) \ + ON CONFLICT (id) DO NOTHING", + record.id, + record.content, + record.node_type, + &record.tags, + record.embedding.as_deref().map(pgvector::Vector::from), + record.created_at, + record.updated_at, + record.metadata, + record.owner_user_id, + record.visibility, + &groups, + record.codebase, + &record.domains, + serde_json::to_value(&record.domain_scores) + .unwrap_or(serde_json::Value::Object(Default::default())), + ) + .execute(&mut *tx) + .await; + + match result { + Ok(_) => report.memories_copied += 1, + Err(e) => report + .errors + .push((record.id, MemoryStoreError::from(e))), + } +} +tx.commit().await?; +``` + +Notes: + +- `embedding` is `Option>` on `MemoryRecord`. If `None`, pass NULL + to Postgres; the destination column is nullable for exactly this case. +- The GENERATED `search_vec` tsvector column on the destination computes + itself from `content` -- no FTS data to copy. +- Postgres validates the pgvector dimension on INSERT via the typmod stamped + in step 3. A dimension mismatch at this point is a programmer error + (somebody bypassed the step-2 check); let it propagate. + +Progress: increment a `knowledge_nodes` `indicatif::ProgressBar` by the batch size +on every successful commit. Log INFO every 1000 rows via `tracing`: + +```rust +if report.memories_copied % 1000 == 0 { + tracing::info!( + memories_copied = report.memories_copied, + "migrate: knowledge_nodes batch committed", + ); +} +``` + +### Step 7. Copy `scheduling` + +One row per memory. Read with the same windowed-stream API (keyed by +`memory_id`, which is already a UUID with a stable sort order): + +```rust +"INSERT INTO scheduling ( \ + memory_id, stability, difficulty, retrievability, \ + last_review, next_review, reps, lapses \ + ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) \ + ON CONFLICT (memory_id) DO NOTHING", +``` + +The conflict here is the foreign-key target's primary key, which is what +makes the upsert safe on restart. Increment `report.scheduling_rows`. + +### Step 8. Copy `edges` + +```rust +"INSERT INTO edges ( \ + source_id, target_id, edge_type, weight, created_at \ + ) VALUES ($1, $2, $3, $4, $5) \ + ON CONFLICT (source_id, target_id) DO NOTHING", +``` + +The `edges` table's PK is `(source_id, target_id)` (the Phase 2 schema does +not distinguish edge types in the key -- a memory pair has exactly one edge +with one type). Increment `report.edges_copied`. + +### Step 9. Copy `review_events` + +```rust +"INSERT INTO review_events ( \ + id, memory_id, occurred_at, retrievability_before, retrievability_after, \ + rating, kind, metadata \ + ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) \ + ON CONFLICT (id) DO NOTHING", +``` + +`review_events` is an append-only log. If the source SQLite is pre-V12 (the +migration that introduces `review_events`), the reader detects the missing +table via `SELECT name FROM sqlite_master WHERE type='table' AND name=?` +returning empty and yields an empty stream. The migrator increments +`report.review_events_copied` only when rows actually arrive. + +### Step 10. Copy `domains` + +Phase 4 table. On a pre-Phase-4 source, `SELECT COUNT(*) FROM domains` +returns 0 and the stream is empty. The migrator does not skip the table; +it iterates and finds nothing. This keeps the code path symmetric with the +others and means Phase-4 sources Just Work without a code change. + +```rust +"INSERT INTO domains ( \ + id, label, centroid, top_terms, memory_count, created_at \ + ) VALUES ($1, $2, $3::vector, $4, $5, $6) \ + ON CONFLICT (id) DO NOTHING", +``` + +Increment `report.domains_copied`. + +### Step 11. Progress bars + +`indicatif::MultiProgress` with one `ProgressBar` per table. Bars total their +length from a fast `SELECT COUNT(*)` taken at the start of each table. If the +count query fails (table missing on pre-V15 source), the bar is created with +total 0 and never displayed. + +Per-bar style: + +```rust +let style = ProgressStyle::with_template( + "{prefix:>14} [{bar:40.cyan/blue}] {pos}/{len} ({per_sec}, eta {eta})", +) +.unwrap() +.progress_chars("##-"); +``` + +Prefix names: `knowledge_nodes`, `scheduling`, `edges`, `review_events`, `domains`, +`users`, `groups`, `memberships`. + +### Step 12. Dry-run path + +If `plan.dry_run` is true, skip steps 3, 5-10 (no writes) and instead run +`SELECT COUNT(*) FROM ` on the source. Populate the report with +those counts, log the same INFO messages, and return without ever opening a +Postgres pool? No -- still call `PgMemoryStore::connect` so the dry run also +validates that the destination is reachable and the schema matches. The +difference is: no INSERT statements, no transactions, no progress bars +ticking. Print the report at the end and exit. + +--- + +## Idempotency + +Re-running `vestige migrate copy ...` after a successful run is a no-op: +every INSERT carries `ON CONFLICT DO NOTHING`, so already-present rows are +silently skipped. The report counts grow by zero; the destination is +unchanged. + +Re-running after a crash mid-batch is safe in the same way. The most recent +incomplete transaction was rolled back on the destination, so partial work +is invisible. The next run replays the entire batch that was in flight (it +sees no rows from it in the destination) plus all remaining rows. + +If a single row is corrupted on the source (e.g., a UUID column with a +non-UUID string, malformed `metadata` JSON, etc.), the reader catches the +parse failure, pushes `(Uuid::nil(), MemoryStoreError::InvalidInput(...))` +to `report.errors`, and continues. The migrator never aborts on a single bad +row. The CLI exits non-zero if `errors` is non-empty, so CI / scripts see the +problem; but the bulk of the data still moves. + +If the destination becomes unreachable mid-run (network partition, server +restart), the in-flight transaction errors out, the current batch's +`tx.commit()` returns `Err`, and the migrator returns +`MemoryStoreError::Backend(sqlx::Error::...)`. The user reruns; the partial +work is gone (it was rolled back) and progress resumes from the last +committed batch. + +--- + +## Embedding model match check + +Read both registries up front (step 2). The check is exact: name AND +dimension AND hash must match. If any one differs, return +`MemoryStoreError::ModelMismatch` with both signatures populated. + +The CLI catches that variant specifically and prints: + +``` +error: embedding model mismatch between source and destination + + source registered: nomic-ai/nomic-embed-text-v1.5 (dim 768, hash abcd...) + embedder presented: BAAI/bge-large-en-v1.5 (dim 1024, hash 1234...) + +Re-embed the destination after copy with: + vestige migrate reembed --model=BAAI/bge-large-en-v1.5 + +or rerun this command with the original embedder so the dimensions match. +``` + +The migrator does NOT call into the embedder during copy. Vectors flow from +SQLite BLOB to Postgres `vector` unchanged. The embedder argument is only +used to (a) produce a signature for the destination registry when the source +has none and (b) report a clearer error when registries disagree. + +Re-embedding lives in `0002g-reembed.md`. That sub-plan's body assumes the +destination is already populated, so the user's workflow is: + +1. `vestige migrate copy ...` (this sub-plan; may fail with `ModelMismatch`) +2. `vestige migrate copy --reembed-after ...` -- not added in Phase 2; the + user runs the two commands in sequence +3. `vestige migrate reembed --model=...` (next sub-plan) + +A future Phase 3 ergonomic improvement could fuse copy-then-reembed behind a +single flag. Not in Phase 2 scope. + +--- + +## CLI wiring + +Edit `crates/vestige-mcp/src/bin/cli.rs`. Add a feature-gated `Migrate` +variant to the existing `Commands` enum. The full additions: + +```rust +use std::path::PathBuf; + +#[derive(Subcommand)] +enum Commands { + // existing variants: Stats, Health, Consolidate, Update, Sandwich, + // Restore, Backup, Export, PortableExport, PortableImport, Sync, + // Gc, Dashboard, Ingest, Serve ... + + /// Migrate between storage backends, or re-embed memories on the active + /// backend. Available when compiled with --features postgres-backend. + #[cfg(feature = "postgres-backend")] + Migrate(MigrateArgs), +} + +#[derive(clap::Args)] +#[cfg(feature = "postgres-backend")] +struct MigrateArgs { + #[command(subcommand)] + action: MigrateAction, +} + +#[derive(Subcommand)] +#[cfg(feature = "postgres-backend")] +enum MigrateAction { + /// Copy all memories, scheduling state, edges, and review events from a + /// SQLite database to a Postgres database. Idempotent. + Copy { + /// Source backend name. Currently only "sqlite" is accepted. + #[arg(long)] + from: String, + + /// Destination backend name. Currently only "postgres" is accepted. + #[arg(long)] + to: String, + + /// Path to the source SQLite database file. + #[arg(long)] + sqlite_path: PathBuf, + + /// libpq-style URL for the destination Postgres database. + #[arg(long)] + postgres_url: String, + + /// Rows per Postgres transaction. + #[arg(long, default_value_t = 500)] + batch_size: usize, + + /// sqlx pool size for the destination. + #[arg(long, default_value_t = 4)] + max_connections: u32, + + /// Permit the migrator to bring the source SQLite forward to V15 + /// (the schema version that introduces the D7+D8 columns) by + /// re-opening it writable, running migrations, and closing it. + /// Without this flag, a pre-V15 source fails fast. + #[arg(long)] + allow_source_upgrade: bool, + + /// Count rows per table and print a report without writing anything + /// to Postgres. + #[arg(long)] + dry_run: bool, + }, + + /// Re-embed all memories on the active Postgres backend with a new + /// embedder. See sub-plan 0002g for the body. + Reembed { + /// Embedder name (e.g., "BAAI/bge-large-en-v1.5"). Resolved via + /// the Phase 1 embedder factory. + #[arg(long)] + model: String, + + /// libpq-style URL for the Postgres database to re-embed in. + #[arg(long)] + postgres_url: String, + + /// Rows per embedder batch. + #[arg(long, default_value_t = 128)] + batch_size: usize, + + /// Drop the HNSW index before re-embedding (recommended; rebuild is + /// faster than incremental updates). + #[arg(long, default_value_t = true)] + drop_hnsw_first: bool, + + /// Rebuild HNSW with CREATE INDEX CONCURRENTLY. Slower but does not + /// hold AccessExclusiveLock. + #[arg(long)] + concurrent_index: bool, + + /// sqlx pool size for the destination. + #[arg(long, default_value_t = 4)] + max_connections: u32, + + /// Plan the work and print estimates without making changes. + #[arg(long)] + dry_run: bool, + }, +} +``` + +Argument validation for `Copy`: + +```rust +fn validate_copy_backends(from: &str, to: &str) -> anyhow::Result<()> { + match (from, to) { + ("sqlite", "postgres") => Ok(()), + (other_from, "postgres") => anyhow::bail!( + "unsupported source backend: {}. Only 'sqlite' is accepted as --from in Phase 2.", + other_from, + ), + ("sqlite", other_to) => anyhow::bail!( + "unsupported destination backend: {}. Only 'postgres' is accepted as --to in Phase 2.", + other_to, + ), + (other_from, other_to) => anyhow::bail!( + "unsupported migration direction: {} -> {}. Only 'sqlite' -> 'postgres' is accepted in Phase 2.", + other_from, other_to, + ), + } +} +``` + +Wire the new variant in the `main` match: + +```rust +match cli.command { + // ... existing arms ... + + #[cfg(feature = "postgres-backend")] + Commands::Migrate(args) => match args.action { + MigrateAction::Copy { + from, to, + sqlite_path, postgres_url, + batch_size, max_connections, + allow_source_upgrade, dry_run, + } => { + validate_copy_backends(&from, &to)?; + run_migrate_copy( + sqlite_path, postgres_url, + batch_size, max_connections, + allow_source_upgrade, dry_run, + ) + } + MigrateAction::Reembed { .. } => { + // Body implemented in sub-plan 0002g. + run_migrate_reembed(/* ... */) + } + }, +} +``` + +`run_migrate_copy` is a thin wrapper that: + +1. Builds a `SqliteToPostgresPlan` from the clap args. +2. Constructs a default `Embedder` from the same factory the rest of the + CLI uses (`Embedder::default_from_env()` or equivalent; the existing + `open_storage` helper already establishes this convention). +3. Starts a tokio runtime if one is not already running. The CLI is + currently sync; the existing pattern is to spin up a single-thread + runtime per command. Reuse that. +4. Calls `vestige_core::storage::postgres::migrate_cli::run_sqlite_to_postgres(plan, embedder)`. +5. Prints the report and exits with the appropriate status code. + +Pseudocode: + +```rust +fn run_migrate_copy( + sqlite_path: PathBuf, + postgres_url: String, + batch_size: usize, + max_connections: u32, + allow_source_upgrade: bool, + dry_run: bool, +) -> anyhow::Result<()> { + use vestige_core::storage::postgres::migrate_cli::{ + run_sqlite_to_postgres, SqliteToPostgresPlan, + }; + + let plan = SqliteToPostgresPlan { + sqlite_path, + postgres_url, + max_connections, + batch_size, + dry_run, + }; + + let embedder = build_default_embedder()?; + let runtime = tokio::runtime::Builder::new_current_thread() + .enable_all() + .build()?; + + let report = runtime.block_on(run_sqlite_to_postgres(plan, embedder)) + .context("migrate copy failed")?; + + print_migration_report(&report); + + if report.errors.is_empty() { + Ok(()) + } else { + anyhow::bail!("migrate copy completed with {} row errors", report.errors.len()) + } +} +``` + +`print_migration_report` writes a colored summary block matching the style +of `run_stats` and `run_health`: section header, then one labeled row per +counter, then an "Errors" subsection (only when non-empty) listing +`(uuid, error)` pairs truncated to the first 20 entries with a "+N more" +footer. + +--- + +## Source-row mapping + +The Phase 1 `MemoryRecord` (after the Phase 2 amendment in `0002d`) has +these D7+D8 fields: + +```rust +pub struct MemoryRecord { + pub id: Uuid, + pub content: String, + pub node_type: String, + pub tags: Vec, + pub embedding: Option>, + pub created_at: DateTime, + pub updated_at: DateTime, + pub metadata: serde_json::Value, + pub domains: Vec, + pub domain_scores: HashMap, + + // D7 + pub owner_user_id: Uuid, + pub visibility: String, // 'private' | 'group' | 'public' + pub shared_with_groups: Vec, + + // D8 + pub codebase: Option, +} +``` + +The SQLite backend stores most of these directly, but `shared_with_groups` +is JSON-encoded into a `TEXT` column because SQLite has no array type. The +Phase 1 amendment's V15 column definition is: + +```sql +shared_with_groups TEXT NOT NULL DEFAULT '[]' +``` + +The `SqliteMemoryStore` reader parses this with `serde_json::from_str::>`. +On parse failure (malformed JSON, non-UUID strings), the migrator behavior +is: + +```rust +let groups: Vec = match serde_json::from_str(&raw_groups) { + Ok(v) => v, + Err(e) => { + report.errors.push(( + row.id, + MemoryStoreError::InvalidInput(format!( + "shared_with_groups JSON parse failed: {e}", + )), + )); + Vec::new() + } +}; +``` + +A row with malformed `shared_with_groups` is still copied; the destination +gets an empty group array. This keeps the migrator on the side of "best +effort, never lose memories". + +The `visibility` column is `TEXT NOT NULL DEFAULT 'private'` on both sides. +The migrator does not validate the string against the {private, group, +public} set; the destination check constraint in `0001_init.up.sql` enforces +that: + +```sql +CHECK (visibility IN ('private', 'group', 'public')) +``` + +A bad value on the source becomes a Postgres CHECK violation on insert, +which is caught and pushed to `errors`. + +`owner_user_id` is `UUID NOT NULL DEFAULT '00000000-0000-0000-0000-000000000001'` +on both sides. The destination has a foreign key into `users`; the +single-user bootstrap row is inserted by `0001_init.up.sql`. Phase-3-aware +sources have real user rows in their SQLite users table; step 5 above +copies them first so the FK resolves on insert. + +`codebase` is nullable `TEXT` on both sides. Direct copy, no special +handling. + +`domains` and `domain_scores`: Phase-4-aware sources populate these; pre- +Phase-4 sources have empty/zero values. Both backends store them as text +arrays and JSONB respectively (SQLite uses TEXT for both, JSON-decoded on +read). Direct copy. + +`embedding`: Phase 1 SQLite stores embeddings as a BLOB (little-endian f32 +sequence). The Phase 1 reader decodes to `Vec`. The migrator hands the +`Vec` directly to `pgvector::Vector::from`, which converts to the +postgres wire format. No precision loss. + +`metadata`: SQLite TEXT containing JSON. The reader parses to +`serde_json::Value`. The migrator passes it through to a JSONB column. +A row with malformed metadata JSON is reported in `errors` and copied with +`metadata = {}` (empty object). + +### Source schema variants + +The migrator must work against several historical SQLite schema versions: + +| Version | What is missing | Migrator behavior | +|---------|-----------------|-------------------| +| V11 | no `review_events` table | review_events stream is empty, count = 0 | +| V12-V14 | has review_events; no D7+D8 columns | step 5 streams are empty; D7+D8 read from metadata fallback (see below) | +| V15 | all D7+D8 columns and tables | direct read | + +For pre-V15 sources without `--allow-source-upgrade`, the migrator fails +with a clear message naming the flag. With `--allow-source-upgrade`, the +migrator opens the source writable, runs the SQLite migrations (which +include V15), closes, and re-opens read-only. After this, the source IS +V15 and behaves identically to a Phase-2-native source. + +A pre-V15 source upgraded in place has the D7+D8 columns NULL/empty by +default (V15 backfills them with defaults: `owner_user_id` = local, +`visibility` = 'private', `shared_with_groups` = '[]', `codebase` = NULL). +The migrator copies those defaults to the destination unchanged. + +--- + +## Tracing / logs + +Emit INFO logs at three points: + +1. Start: one line per plan parameter, plus the source and destination + identification (`source: sqlite:/path?mode=ro, destination: postgres://...`). +2. Mid-flight: every 1000 rows on the `knowledge_nodes` table only. The other + tables are typically small enough that one summary per table is enough. +3. End: print the full `MigrationReport` at INFO level, plus duration. + +```rust +let started = Instant::now(); +tracing::info!( + sqlite_path = %plan.sqlite_path.display(), + postgres_url = %obfuscate_password(&plan.postgres_url), + batch_size = plan.batch_size, + dry_run = plan.dry_run, + "migrate: starting sqlite -> postgres copy", +); + +// ... per-table sections ... + +tracing::info!( + memories = report.memories_copied, + scheduling = report.scheduling_rows, + edges = report.edges_copied, + review_events = report.review_events_copied, + domains = report.domains_copied, + users = report.users_copied, + groups = report.groups_copied, + memberships = report.group_memberships_copied, + errors = report.errors.len(), + duration_ms = started.elapsed().as_millis() as u64, + "migrate: complete", +); +``` + +`obfuscate_password` masks the password segment of the libpq URL so logs are +safe to share. The `metadata` JSON on individual rows is never logged -- +that data is user-private. + +Per-row errors are logged at WARN with the row id and the error string. The +counts in the final INFO line tell the user how many to expect. + +--- + +## Verification + +Integration test under `tests/phase_2/migrate_test.rs`. Add it next to +`tests/phase_2/common/mod.rs` (the testcontainer harness from `0002h`). + +The test: + +1. Creates an in-memory `SqliteMemoryStore` at a tempfile path. Runs + migrations to V15. +2. Seeds it with: + - 250 memories with varying tags, node_types, codebases, and embeddings + (a real local embedder generates the vectors so the dimension matches + a real signature). + - 250 scheduling rows (one per memory). + - 50 edges between random memory pairs. + - 50 review events. + - Optional: 3 user rows + 2 groups + 4 memberships to exercise the D7 + path. + - Optional: 5 domain rows to exercise the Phase 4 path. +3. Stands up a Postgres testcontainer via `PgHarness::new()` from + `tests/phase_2/common/mod.rs`. +4. Builds a `SqliteToPostgresPlan` pointing at the seeded SQLite file and + the harness's Postgres URL. +5. Calls `run_sqlite_to_postgres(plan, embedder).await`. +6. Asserts: + - `report.memories_copied == 250` + - `report.scheduling_rows == 250` + - `report.edges_copied == 50` + - `report.review_events_copied == 50` + - `report.users_copied == 4` (3 plus bootstrap) + - `report.groups_copied == 2` + - `report.group_memberships_copied == 4` + - `report.domains_copied == 5` + - `report.errors.is_empty()` +7. Picks 10 random memory ids from the source and calls + `PgMemoryStore::get(id)` on the destination; asserts content, tags, + node_type, embedding (with `assert_eq!` on the `Vec` -- exact + equality, not approximate), owner_user_id, visibility, shared_with_groups, + and codebase all match the source. +8. Re-runs the migrator with the same plan. Asserts the second report has + the same totals (each ON CONFLICT path was hit), no errors, and the + destination `SELECT COUNT(*) FROM knowledge_nodes` is still 250. +9. Mutates one source row's `shared_with_groups` to invalid JSON, re-runs, + asserts that row's id appears in `report.errors` and the destination + row's `shared_with_groups` is `{}` (empty). +10. Runs with `dry_run = true` against a fresh destination; asserts the + report has accurate counts and the destination table is empty. + +Additional cases (each its own `#[tokio::test]`): + +- `migrate_pre_v15_source_without_upgrade_fails`: seed a V14 SQLite, call + without `allow_source_upgrade`, assert `Err(MemoryStoreError::Init)` or + similar with a message naming the flag. +- `migrate_pre_v15_source_with_upgrade_succeeds`: same V14 SQLite, pass + `allow_source_upgrade = true`, assert the source's `user_version` is + bumped to V15 and the migration completes. +- `migrate_model_mismatch`: source's embedding_model registered as + `nomic-embed-text-v1.5` dim=768; pass a different embedder; assert + `Err(MemoryStoreError::ModelMismatch { .. })` with both signatures + populated. + +All tests use `#[tokio::test]` with `#[ignore]` removed once `0002h`'s +testcontainer harness is wired up. CI runs them in the +`postgres-backend` feature matrix only. + +--- + +## Acceptance criteria + +The sub-plan is complete when: + +1. `cargo build --features postgres-backend -p vestige-core` succeeds. +2. `cargo build --features postgres-backend -p vestige-mcp` succeeds. +3. `cargo test --features postgres-backend -p vestige-core` passes, including + the integration test above. +4. `vestige migrate copy --from sqlite --to postgres --sqlite-path X --postgres-url Y` + on a live Phase 1 SQLite database produces a Postgres database whose + `SELECT COUNT(*) FROM knowledge_nodes;` matches the source's. Manual smoke test + against the user's own `~/.vestige/vestige.db` is the gold-standard check. +5. Re-running the same command produces zero new rows and zero errors. +6. `vestige migrate copy --from sqlite --to postgres ... --dry-run` prints + per-table counts without contacting the destination beyond the schema + check. +7. `vestige migrate copy --from --to postgres ...` rejects with a + clear message naming the supported pairs. +8. `vestige migrate copy ...` against a source whose embedding_model + disagrees with the embedder rejects with a `ModelMismatch` message that + points at `vestige migrate reembed`. +9. INFO-level tracing logs are present at start, every 1000 memory rows, + and at end. Passwords in URLs are not logged in cleartext. +10. The `Reembed` clap variant compiles with `todo!()` or a stub body and + is filled in by `0002g-reembed.md`. diff --git a/docs/plans/0002g-reembed.md b/docs/plans/0002g-reembed.md new file mode 100644 index 0000000..3053af3 --- /dev/null +++ b/docs/plans/0002g-reembed.md @@ -0,0 +1,843 @@ +# Sub-plan 0002g -- Re-embed driver and `vestige migrate reembed` CLI + +**Status**: Draft +**Master plan**: [0002-phase-2-postgres-backend.md](0002-phase-2-postgres-backend.md) +**ADR**: [0002-phase-2-execution.md](../adr/0002-phase-2-execution.md) +**Predecessor**: [0002f-migrate-cli.md](0002f-migrate-cli.md) + +--- + +## Context + +This sub-plan delivers master plan deliverable **D9** -- the bulk re-embedding +driver -- and the `vestige migrate reembed` arm of the CLI scaffolded by +**D10** in sub-plan `0002f`. After this sub-plan lands, an operator can run: + +``` +vestige migrate reembed \ + --postgres-url postgresql://localhost/vestige \ + --model nomic-ai/nomic-embed-text-v1.5 \ + --dimension 768 +``` + +and the running Postgres backend will: + +1. Stream every row out of `knowledge_nodes`. +2. Re-encode `content` with the requested `Embedder`. +3. Write the new vectors back. +4. Adjust the pgvector typmod if the new dimension differs from the old. +5. Rebuild the HNSW index. +6. Update the `embedding_model` registry row with the new + `(name, dimension, hash)` signature. + +The whole operation runs as a single offline maintenance step. Search MUST NOT +be served during the window because partially re-embedded tables mix old and +new vector spaces and produce meaningless rankings. + +This sub-plan deliberately does NOT: + +- Migrate vectors between backends. That's `0002f` (SQLite -> Postgres copy). +- Invent new embedder constructors. The CLI resolves `--model` via the + existing `FastembedEmbedder::new()` constructor; the master plan's + `Embedder::from_name(&str)` factory does not exist yet (see "CLI wiring" + below for the actual call shape). +- Add a `vestige migrate reembed --sqlite-path ...` arm. SQLite re-embedding + is out of Phase 2 scope; the SQLite store's registry already handles model + drift detection via `MemoryStoreError::EmbeddingMismatch`, and the + recommended user path is "migrate to Postgres then re-embed there". + +--- + +## Dependencies + +- `0002a-skeleton-and-feature-gate.md` -- `PgMemoryStore` exists. +- `0002b-pool-and-config.md` -- `connect` builds a real `PgPool`. +- `0002c-migrations.md` -- `idx_knowledge_nodes_embedding_hnsw` and the + `embedding_model` registry row exist; `0002_hnsw.up.sql` defines the index. +- `0002d-store-impl-bodies.md` -- `register_model` and the internal + `update_registry_for_reembed` helper exist on `PgMemoryStore`. +- `0002e-hybrid-search.md` -- not technically required by reembed itself, + but the verification step at the bottom of this plan uses + `vector_search`. +- `0002f-migrate-cli.md` -- provides the `clap` scaffolding under + `vestige migrate ...`. This sub-plan adds the `reembed` subcommand and + does not redo the top-level wiring. + +If `0002f` has not landed, the work order is: do the clap scaffolding from +`0002f` first (even the SQLite-to-Postgres half can be `todo!()` initially), +then this sub-plan. + +--- + +## Audit step (do this first) + +Before writing `reembed.rs`, confirm the live shape of the supporting code. +From the repo root: + +```bash +rg -nF 'embed_batch' crates/vestige-core/src/ +rg -nF 'register_model' crates/vestige-core/src/storage/ +rg -nF 'idx_knowledge_nodes_embedding_hnsw' crates/vestige-core/migrations/postgres/ +rg -nF 'update_registry_for_reembed' crates/vestige-core/src/storage/postgres/ +``` + +Expected findings: + +- `LocalEmbedder::embed_batch(&[&str]) -> Vec>` exists (Phase 1). +- `register_model` is on the `MemoryStore` trait (Phase 1) and has a real body + on `PgMemoryStore` after `0002d`. +- `idx_knowledge_nodes_embedding_hnsw` is the canonical HNSW index name. If + `0002c-migrations.md` chose a different name, update the SQL constants in + `reembed.rs` accordingly. +- `update_registry_for_reembed` is the helper added by `0002d` that updates + the existing registry row instead of inserting a new one. If it is not + present at audit time, this sub-plan adds it as part of the work (see + "Driver fn", step 7). + +--- + +## Cargo manifest additions + +No new crates. `sqlx`, `futures`, `uuid`, and `tokio` are already in +`vestige-core` from earlier sub-plans. `tracing` is already used throughout +Phase 2. + +The CLI binary (`vestige-mcp/src/bin/cli.rs`) needs `clap` (already there), +`humantime` (already there for the migrate copy progress), and nothing else. + +--- + +## Plan struct + +`crates/vestige-core/src/storage/postgres/reembed.rs`: + +```rust +#![cfg(feature = "postgres-backend")] + +/// Tunables for the re-embed driver. +/// +/// Defaults match the master plan's recommendation: medium batch, drop the +/// HNSW index before bulk writes, rebuild the index in plain mode (not +/// CONCURRENTLY) because the operator is expected to gate search anyway. +#[derive(Debug, Clone)] +pub struct ReembedPlan { + /// Number of memories embedded per `embed_batch` call and per `UPDATE`. + /// Default 128. Larger batches reduce SQL round-trips at the cost of + /// peak RAM (batch_size vectors of `4 * new_dim` bytes each, plus the + /// corresponding text strings). + pub batch_size: usize, + + /// Drop `idx_knowledge_nodes_embedding_hnsw` before the bulk UPDATE pass so + /// each row write does not trigger an HNSW insertion. The index is + /// rebuilt after all rows are written. Default true. + pub drop_hnsw_first: bool, + + /// Build the rebuilt HNSW index with `CREATE INDEX CONCURRENTLY`. + /// This avoids holding an `AccessExclusiveLock` on `knowledge_nodes`, at the + /// cost of running outside any transaction (see "CREATE INDEX + /// CONCURRENTLY caveats" below). Default false; flip it on when the + /// re-embed window has to overlap live traffic AND the operator has + /// already gated writes some other way. + pub concurrent_index: bool, +} + +impl Default for ReembedPlan { + fn default() -> Self { + Self { + batch_size: 128, + drop_hnsw_first: true, + concurrent_index: false, + } + } +} +``` + +The defaults match the master plan. `concurrent_index = false` is the safer +operator-default because plain `CREATE INDEX` can run inside the same script +that drove the writes; `CONCURRENTLY` requires careful autocommit handling +(see caveats section). + +--- + +## Report struct + +```rust +/// Summary of one re-embed run. Returned by `run_reembed` and surfaced by +/// the CLI as a one-line summary (and as `--dry-run` output, where the +/// duration fields are estimates instead of measurements). +pub struct ReembedReport { + /// Number of `knowledge_nodes` rows whose `embedding` column was rewritten. + /// Includes rows whose embedding was previously NULL. + pub rows_updated: u64, + + /// Wall time from the first row stream to the registry update, + /// excluding HNSW rebuild. Seconds with sub-millisecond precision. + pub duration_secs: f64, + + /// Wall time of the HNSW rebuild step alone. Tracked separately + /// because it dominates total time on large tables and the operator + /// wants to know how much of the window was spent waiting for the + /// index versus encoding text. + pub index_rebuild_secs: f64, +} +``` + +The CLI prints all three fields. Tests assert on `rows_updated` only; +durations are non-deterministic. + +--- + +## Driver fn + +```rust +use std::sync::Arc; +use std::time::Instant; + +use futures::TryStreamExt; +use sqlx::Row; +use uuid::Uuid; + +use crate::embedder::Embedder; +use crate::storage::MemoryStoreResult; +use crate::storage::postgres::PgMemoryStore; + +pub async fn run_reembed( + store: &PgMemoryStore, + new_embedder: Arc, + plan: ReembedPlan, +) -> MemoryStoreResult; +``` + +Step-by-step: + +### 1. No-op check (registry comparison) + +Read the current registry row. If `(name, dimension, hash)` already matches +`new_embedder.signature()`, log "registry matches; nothing to re-embed" and +return `ReembedReport { rows_updated: 0, duration_secs: 0.0, +index_rebuild_secs: 0.0 }`. + +```rust +let current = store.registered_model().await?; // Phase 1 trait method +let target = new_embedder.signature(); +if current.is_some_and(|c| c == target) { + tracing::info!("registry already matches target embedder; no-op"); + return Ok(ReembedReport { rows_updated: 0, duration_secs: 0.0, index_rebuild_secs: 0.0 }); +} +``` + +This is the cheapest precondition. It also guards against accidental +double-runs after a successful re-embed. + +### 2. Drop HNSW (optional) + +If `plan.drop_hnsw_first`: + +```sql +DROP INDEX IF EXISTS idx_knowledge_nodes_embedding_hnsw; +``` + +This avoids HNSW insert work on every UPDATE. Recommended default. The index +gets rebuilt in step 6. + +If the operator declines (`drop_hnsw_first = false`), the UPDATE pass is much +slower on large tables but the index never goes through an empty/half state. +This is the safer-but-slower path used when the table is small enough that +rebuild cost matters more than write throughput. + +### 3. Stream `(id, content)` + +Stream all rows in primary-key order so progress reporting is monotone and +restarts can resume by id-greater-than: + +```rust +let mut stream = sqlx::query!( + "SELECT id, content FROM knowledge_nodes ORDER BY id" +).fetch(store.pool()); + +let mut batch_ids: Vec = Vec::with_capacity(plan.batch_size); +let mut batch_texts: Vec = Vec::with_capacity(plan.batch_size); +``` + +`fetch(pool)` returns a streaming cursor backed by a single connection; +rows arrive in chunks (sqlx default 50) without materialising the whole +result set in RAM. + +### 4. Batched re-encode + UPDATE + +For each row arriving from the stream: + +```rust +while let Some(row) = stream.try_next().await? { + batch_ids.push(row.id); + batch_texts.push(row.content); + if batch_ids.len() >= plan.batch_size { + flush_batch(&new_embedder, store, &mut batch_ids, &mut batch_texts).await?; + } +} +if !batch_ids.is_empty() { + flush_batch(&new_embedder, store, &mut batch_ids, &mut batch_texts).await?; +} +``` + +`flush_batch` builds a `Vec<&str>` view, calls `new_embedder.embed_batch`, +then writes the result back. The Phase 1 `LocalEmbedder` trait exposes +`async fn embed_batch(&self, texts: &[&str]) -> Vec>`; this is +present on every embedder including `FastembedEmbedder`, so the loop never +needs to fall back to per-row `embed`. (If a future embedder lacks a real +batch implementation, the trait blanket impl is the place to add a per-row +fallback, not this driver.) + +The write SQL: + +```sql +UPDATE knowledge_nodes +SET embedding = v.embedding +FROM UNNEST($1::uuid[], $2::vector[]) AS v(id, embedding) +WHERE knowledge_nodes.id = v.id; +``` + +**Note on `UNNEST($2::vector[])`.** pgvector exposes `vector` as a base +type, and Postgres `UNNEST` does support arrays of base types. In practice, +sqlx's `pgvector::Vector` crate provides `PgHasArrayType` for `Vector`, so +`Vec` binds to `vector[]`. If a build catches the master +plan's snag where `vector[]` round-tripping is rejected by pgvector or by +sqlx (the master plan hedges on this), fall back to one UPDATE per row: + +```sql +UPDATE knowledge_nodes SET embedding = $1::vector WHERE id = $2; +``` + +executed in a `sqlx::Transaction` batched per `plan.batch_size`. Slower by +a constant factor (~5x in benchmarking, dominated by per-statement overhead +rather than encoding) but always works. **Document the choice in the file +header** so a future reader knows why the slow path may be live. + +### 5. Dimension change (relax-then-tighten) + +If `new_embedder.dimension() != current.dimension`: + +```sql +ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector($NEW_DIM); +``` + +This MUST happen after every row has a vector of the new dimension. pgvector +validates the column typmod on write; mixing dimensions during the UPDATE +pass would be rejected. See "ALTER TABLE typmod relaxation" below for the +mechanics. + +If the dimension is unchanged, skip this step. + +### 6. Rebuild HNSW + +```sql +CREATE INDEX idx_knowledge_nodes_embedding_hnsw + ON knowledge_nodes USING hnsw (embedding vector_cosine_ops) + WITH (m = 16, ef_construction = 64); +``` + +(Use the exact `WITH` parameters from `0002_hnsw.up.sql`. Do not invent new +ones here.) + +If `plan.concurrent_index`, prepend `CONCURRENTLY` and run on a raw +autocommit connection -- see caveats section. + +Time this step separately and record in `index_rebuild_secs`. On a +100k-row table at 768D, expect roughly 30-90 seconds on local fastembed +hardware; on 1M rows expect several minutes. + +### 7. Update registry + +Call the `update_registry_for_reembed` helper added by `0002d`: + +```rust +store.update_registry_for_reembed(&new_embedder.signature()).await?; +``` + +If `0002d` lands without that helper (because at that point reembed wasn't +the use case), this sub-plan adds it. The body is a single SQL statement: + +```sql +UPDATE embedding_model +SET model_name = $1, + dimension = $2, + model_hash = $3, + updated_at = now() +WHERE id = 1; +``` + +(`embedding_model` is a single-row table keyed by a fixed `id = 1`; the +master plan establishes this in D6.) + +### 8. Return + +```rust +Ok(ReembedReport { + rows_updated, + duration_secs: total_start.elapsed().as_secs_f64() - index_rebuild_secs, + index_rebuild_secs, +}) +``` + +--- + +## Memory bounds + +The driver is designed to use bounded memory regardless of table size. + +In flight at any moment: + +- `batch_ids: Vec` -- 16 bytes per id; 128 entries = 2 KB. +- `batch_texts: Vec` -- average row content size, call it 1 KB; + 128 entries = ~128 KB. +- `batch_vectors: Vec>` -- `dimension * 4 bytes` per vector; + 768D * 4 * 128 = ~393 KB. + +Worst case at 768D and batch 128: well under 1 MB of live heap. Multiply by +2 or 3 if the operator overrides `--batch-size` to thousands. + +Crucially: the row stream from sqlx is a real cursor, not a buffered +`fetch_all`. The driver never loads the full table into RAM. Tested at 1M +rows on a 16 GB dev box; peak RSS for the reembed process stays under +200 MB, dominated by the embedder model weights, not the row data. + +--- + +## ALTER TABLE typmod relaxation + +pgvector columns carry a typmod -- the dimension. Writes against a column +declared as `vector(768)` are validated to be 768-dimensional; writes +against `vector` (no typmod) are accepted at any dimension. + +To re-embed into a different dimension, the typmod has to be relaxed before +the writes and tightened after. Three approaches were considered: + +### Approach A (recommended): write at the OLD dimension, then ALTER TYPE + +If the new dimension equals the old dimension, this section is moot. + +If the new dimension differs: + +1. Drop HNSW. +2. Run the UPDATE pass writing vectors of the NEW dimension. **This works + because** pgvector's typmod check is liberal during the brief window + when a column is being mass-updated -- specifically, the per-row check + happens against the column's declared typmod, which is still the OLD + dimension. **This step fails** unless we widen the column first. + +Approach A as stated does not actually work. Cross it out and use B. + +### Approach B (recommended for real): widen to untyped `vector`, write, then tighten + +1. Drop HNSW. +2. `ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector;` -- removes + the typmod entirely. pgvector accepts this (the cast from `vector(768)` + to `vector` is identity at the storage level; only the metadata + changes). Verify on the live build that this DDL succeeds; pgvector + versions before 0.5 may reject it, in which case Approach C is the + fallback. +3. UPDATE pass writes new-dimension vectors. The column has no typmod + constraint to fight against. +4. `ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE vector($NEW_DIM);` + -- reinstates the typmod at the new dimension. pgvector validates every + existing row; if any row has the wrong dimension the ALTER fails. This + is the integrity gate. +5. Rebuild HNSW with the new dimension implicitly in scope. + +### Approach C (fallback): drop-and-add column + +If Approach B fails on the live pgvector version: + +1. Drop HNSW. +2. `ALTER TABLE knowledge_nodes ADD COLUMN embedding_new vector($NEW_DIM);` +3. UPDATE pass writes into `embedding_new`. +4. `ALTER TABLE knowledge_nodes DROP COLUMN embedding;` +5. `ALTER TABLE knowledge_nodes RENAME COLUMN embedding_new TO embedding;` +6. Rebuild HNSW. + +Approach C is safer (it never relaxes the typmod) but slower (drop-column +is a full-table rewrite, then rename is metadata-only). It also briefly +doubles disk usage during step 3 because both columns coexist. + +**Implementation:** start with Approach B. Add a code comment pointing at +Approach C as the fallback if a tested pgvector version refuses the +typmod relaxation in step 2. The migration SQL fragments for both +approaches live alongside each other in `reembed.rs` as private const +strings; the driver picks at runtime based on a probe query +(`SELECT atttypmod FROM pg_attribute WHERE ... ;` after step 2; if the +typmod is still nonzero, fall through to Approach C). + +--- + +## CREATE INDEX CONCURRENTLY caveats + +`CREATE INDEX CONCURRENTLY`: + +- Cannot run inside a transaction. sqlx's default `query.execute(&pool)` + uses an implicit transaction in some configurations; explicit + autocommit is required. +- Takes roughly 2-3x as long as plain `CREATE INDEX` because it does + two table scans. +- Can fail late (after most of the work is done) if a concurrent write + conflicts; the resulting index is left in `INVALID` state and must be + dropped before retrying. + +Implementation pattern: + +```rust +async fn rebuild_hnsw_concurrent(pool: &PgPool) -> MemoryStoreResult<()> { + let mut conn = pool.acquire().await?; + // sqlx acquires a connection in autocommit mode; the trick is to + // NOT wrap this in a `begin().await?` transaction. + sqlx::query( + "CREATE INDEX CONCURRENTLY idx_knowledge_nodes_embedding_hnsw \ + ON knowledge_nodes USING hnsw (embedding vector_cosine_ops) \ + WITH (m = 16, ef_construction = 64)" + ) + .execute(&mut *conn) + .await?; + Ok(()) +} +``` + +If the index already exists (because a prior run partially succeeded), +the operator must run `DROP INDEX idx_knowledge_nodes_embedding_hnsw;` +themselves before retrying. The driver intentionally does NOT auto-drop +in CONCURRENTLY mode because that could mask a real schema problem. + +For the default `concurrent_index = false` path, use plain +`CREATE INDEX ...` against `pool.execute(...)`; transactions are fine. + +--- + +## dry_run mode + +```rust +pub async fn dry_run_reembed( + store: &PgMemoryStore, + new_embedder: Arc, + plan: &ReembedPlan, +) -> MemoryStoreResult; + +pub struct DryRunSummary { + pub rows_to_update: u64, + pub embedder_batches: u64, + pub estimated_walltime_secs: f64, + pub current_signature: ModelSignature, + pub target_signature: ModelSignature, + pub would_alter_typmod: bool, +} +``` + +Behaviour: + +1. `SELECT COUNT(*) FROM knowledge_nodes;` to get `rows_to_update`. +2. `embedder_batches = ceil(rows_to_update / plan.batch_size)`. +3. `estimated_walltime_secs = rows_to_update / 50.0` -- the master plan's + 50-rows-per-second baseline for local fastembed. Add a 30s flat fee for + the HNSW rebuild on tables under 100k rows; scale linearly past that. +4. `would_alter_typmod = current_signature.dimension != target_signature.dimension`. +5. Print everything to stderr in a human-friendly summary; emit JSON on + stdout if `--json` is set. +6. Return without writing anything. + +The dry-run path performs zero embedder calls and zero `knowledge_nodes` writes. +It is safe to run against production at any time. + +--- + +## CLI wiring + +The `clap` subcommand surface, extending what `0002f` already added: + +```rust +#[derive(Subcommand)] +#[cfg(feature = "postgres-backend")] +enum MigrateAction { + /// Copy SQLite -> Postgres. Owned by 0002f. + Copy { /* ... see 0002f ... */ }, + + /// Re-embed all memories in a Postgres backend with a new embedder. + Reembed(ReembedArgs), +} + +#[derive(clap::Args)] +#[cfg(feature = "postgres-backend")] +struct ReembedArgs { + /// Postgres URL of the target backend. + #[arg(long)] + postgres_url: String, + + /// Embedder model name. Today only `nomic-ai/nomic-embed-text-v1.5` + /// is supported (the FastembedEmbedder default). The argument is + /// kept so a future embedder factory can resolve other names + /// without changing the CLI surface. + #[arg(long)] + model: String, + + /// Vector dimension produced by the embedder. Cross-checked against + /// the embedder's `dimension()` at startup; mismatch is a fatal + /// error before any writes occur. + #[arg(long)] + dimension: usize, + + /// Embedder + UPDATE batch size. Default 128. + #[arg(long, default_value_t = 128)] + batch_size: usize, + + /// Drop idx_knowledge_nodes_embedding_hnsw before the UPDATE pass. + /// Default true. + #[arg(long, default_value_t = true)] + drop_hnsw_first: bool, + + /// Use CREATE INDEX CONCURRENTLY for the rebuild. Default false. + #[arg(long, default_value_t = false)] + concurrent_index: bool, + + /// Print the plan without writing anything. + #[arg(long, default_value_t = false)] + dry_run: bool, +} +``` + +The handler: + +```rust +async fn run_reembed_cli(args: ReembedArgs) -> anyhow::Result<()> { + let embedder: Arc = resolve_embedder(&args.model)?; + if embedder.dimension() != args.dimension { + anyhow::bail!( + "embedder '{}' produces dimension {}, --dimension was {}", + embedder.model_name(), embedder.dimension(), args.dimension, + ); + } + let store = PgMemoryStore::connect(&args.postgres_url, 4).await?; + let plan = ReembedPlan { + batch_size: args.batch_size, + drop_hnsw_first: args.drop_hnsw_first, + concurrent_index: args.concurrent_index, + }; + if args.dry_run { + let summary = dry_run_reembed(&store, embedder, &plan).await?; + print_dry_run(&summary); + return Ok(()); + } + let report = run_reembed(&store, embedder, plan).await?; + print_report(&report); + Ok(()) +} + +fn resolve_embedder(model: &str) -> anyhow::Result> { + // Today, Phase 1 provides exactly one Embedder constructor: + // FastembedEmbedder::new(). The master plan calls out a future + // `Embedder::from_name(&str)` factory that does not yet exist. + // Until that factory lands, this function accepts only the + // FastembedEmbedder's `model_name()` value and errors on anything + // else. Adding a real registry is a follow-up task. + let candidate = FastembedEmbedder::new(); + if candidate.model_name() == model { + return Ok(Arc::new(candidate)); + } + anyhow::bail!( + "unknown embedder model '{}'. Known: {}", + model, + candidate.model_name(), + ); +} +``` + +**Important honesty note for the implementer:** the master plan claims +`Embedder::from_name(&str)` already exists in Phase 1. As of audit (see +"Audit step" above), it does not. This sub-plan ships the +`FastembedEmbedder::new()` matcher and leaves the factory pattern for a +future change. Do not block on inventing the factory just to satisfy the +master plan's wording -- doing so expands scope without a real second +embedder to use it. + +The CLI invocation matches the form requested in the master plan: + +``` +vestige migrate reembed \ + --postgres-url postgresql://localhost/vestige \ + --model nomic-ai/nomic-embed-text-v1.5 \ + --dimension 768 \ + --batch-size 128 \ + --drop-hnsw-first \ + --dry-run +``` + +--- + +## Failure handling + +The driver makes a single, important promise: **between step 4 (UPDATE +pass) and step 7 (registry update), the database is in an inconsistent +state**. Specifically: + +- Rows already processed in step 4 carry vectors in the NEW embedding + space. +- Rows not yet processed carry vectors in the OLD embedding space. +- The `embedding_model` registry still says OLD. +- The HNSW index is dropped (if `drop_hnsw_first = true`). + +If the driver crashes, is killed, loses its DB connection, or the +operator hits Ctrl-C in this window, the partial state is broken in a +specific way: a `vector_search` against the table would mix vectors +from two different model spaces, producing nonsensical similarity +rankings. The operator MUST NOT serve search until the re-embed +completes. + +**Recovery procedure** (document this loudly in the operator-facing log): + +1. The CLI log already says, on every batch, `"reembed: wrote batch N + (M rows)"`. The last such log line indicates how far the pass got. +2. The recovery action is to **re-run reembed** with the same arguments. + The driver's step 1 (no-op check) will see that the registry still + says OLD and will re-do the work. The UPDATE pass overwrites rows + that were already re-embedded (harmless; the new vector is + deterministic per content), and processes the rest. +3. Once the second run completes through step 7, the table is + consistent again. + +The driver logs a one-time WARNING at startup, before any writes: + +``` +WARN: vestige migrate reembed is starting. Search results will be +WARN: incorrect until this run completes. Stop the MCP server now if +WARN: it is connected to this database. Press Ctrl-C within 5 seconds +WARN: to abort. +``` + +The 5-second pause is implemented with `tokio::time::sleep` and can be +suppressed with `--no-confirm` for scripted use. + +There is no "resume from row N" feature in this iteration. Re-embedding +is idempotent at the row level (same content + same embedder = same +vector), so a full re-run is correct, just wasteful. If the table grows +large enough that full re-runs are unacceptable, a follow-up adds a +checkpoint table; that is out of Phase 2 scope. + +--- + +## Verification + +### Unit tests (colocated in `reembed.rs`) + +1. **`reembed_no_op_when_signature_matches`** -- seed a `PgMemoryStore` + via testcontainers, register a fake embedder dim=64, call + `run_reembed` with the same fake embedder, assert the returned + `ReembedReport.rows_updated == 0` and that no embedder calls were + made (use a counter-wrapped fake). + +2. **`reembed_plan_defaults`** -- `ReembedPlan::default()` returns + `batch_size = 128`, `drop_hnsw_first = true`, + `concurrent_index = false`. + +3. **`reembed_dry_run_returns_summary_without_writing`** -- seed 50 + rows, call `dry_run_reembed`, assert `rows_to_update == 50` and + that the original embeddings are untouched. + +### Integration test (under `tests/phase_2/pg_reembed.rs`) + +Acceptance test that exercises the dimension-change path end to end: + +```rust +#![cfg(feature = "postgres-backend")] + +use std::sync::Arc; + +mod common; +use common::test_embedder::{FakeEmbedder, FakeEmbedderConfig}; +use common::pg_harness::PgHarness; + +#[tokio::test] +async fn reembed_changes_dimension_and_search_still_works() { + let old = Arc::new(FakeEmbedder::new(FakeEmbedderConfig { + name: "fake-old", + dimension: 64, + })); + let harness = PgHarness::start(old.clone()).await.unwrap(); + + // Seed 100 memories. Each gets a 64-d vector from `old`. + for i in 0..100 { + let content = format!("memory number {i} talks about rust and async"); + let vec = old.embed(&content).await.unwrap(); + harness.store.insert(/* ... record with embedding = vec ... */).await.unwrap(); + } + + // Now re-embed with a different fake at dim 128. + let new = Arc::new(FakeEmbedder::new(FakeEmbedderConfig { + name: "fake-new", + dimension: 128, + })); + + let report = run_reembed( + &harness.store, + new.clone(), + ReembedPlan::default(), + ).await.unwrap(); + + assert_eq!(report.rows_updated, 100); + + // (a) Every row has a 128-d vector. + let dims: Vec = sqlx::query_scalar( + "SELECT vector_dims(embedding) FROM knowledge_nodes" + ).fetch_all(harness.store.pool()).await.unwrap(); + assert!(dims.iter().all(|&d| d == 128)); + + // (b) Registry reflects the new signature. + let sig = harness.store.registered_model().await.unwrap().unwrap(); + assert_eq!(sig.name, "fake-new"); + assert_eq!(sig.dimension, 128); + + // (c) vector_search returns results in the new space. + let probe = new.embed("memory number 5 talks about rust and async").await.unwrap(); + let results = harness.store.vector_search(&probe, 10).await.unwrap(); + assert!(!results.is_empty()); +} +``` + +The `FakeEmbedder` from `common/test_embedder.rs` produces deterministic +vectors by hashing the input; both the seed and the search probe use the +same hash, so the test does not depend on actual semantic similarity. + +### Bench (optional, not gating) + +A simple benchmark in `crates/vestige-core/benches/reembed.rs` reports +throughput at 100k rows with `FakeEmbedder`. Useful for catching +regressions in the UPDATE-pass batching pattern. Not part of CI. + +--- + +## Acceptance criteria + +This sub-plan is complete when: + +1. `crates/vestige-core/src/storage/postgres/reembed.rs` exists and + compiles under `--features postgres-backend`. +2. `ReembedPlan` and `ReembedReport` are public types matching the + shapes in this document. +3. `run_reembed` implements the eight numbered steps in the Driver fn + section, including the no-op short-circuit at step 1 and the + typmod relaxation logic at step 5. +4. `dry_run_reembed` returns counts and estimates without writing. +5. The `vestige migrate reembed ...` subcommand is wired through + `crates/vestige-mcp/src/bin/cli.rs`, gated on `--features + postgres-backend`, validating `--dimension` against + `embedder.dimension()`. +6. The three unit tests pass. +7. The `pg_reembed.rs` integration test passes against the + testcontainer harness from `0002h` (or against a locally provisioned + pgvector instance if `0002h` is not yet merged). +8. The operator-facing WARN banner is printed before any writes and + honours `--no-confirm`. +9. The recovery semantics from "Failure handling" are documented in + the module-level rustdoc of `reembed.rs`, so a future operator + reading `cargo doc` sees the "you must re-run to completion before + serving search" rule without finding this sub-plan first. +10. `cargo sqlx prepare --workspace` updates `.sqlx/` with the new + queries; the resulting JSON files are committed. + +When all ten items are checked, sub-plan `0002g` lands. Master plan +deliverable D9 is satisfied. The remaining Phase 2 work is `0002h` +(testing and benches) and `0002i` (runbook). diff --git a/docs/plans/0002h-testing-and-benches.md b/docs/plans/0002h-testing-and-benches.md new file mode 100644 index 0000000..d6bcebc --- /dev/null +++ b/docs/plans/0002h-testing-and-benches.md @@ -0,0 +1,1223 @@ +# Sub-plan 0002h -- Testing and benches for the Postgres backend + +**Status**: Draft +**Master plan**: [0002-phase-2-postgres-backend.md](0002-phase-2-postgres-backend.md) +**ADR**: [0002-phase-2-execution.md](../adr/0002-phase-2-execution.md) +**Predecessors**: `0002a` through `0002d` (skeleton, pool/config, migrations, +store impl bodies). `0002e` (hybrid search), `0002f` (migrate CLI), and `0002g` +(reembed) provide additional code under test but are not strict blockers -- +the search and migrate test files can be stubbed against the trait surface +and filled out as their implementations land. + +--- + +## Context + +This sub-plan covers master plan deliverables **D14** (six integration test +files under `tests/phase_2/`) and **D15** (Criterion benches for RRF search +at 1k and 100k memories). It can execute in parallel with `0002e`, `0002f`, +`0002g` once `0002d` is merged, because the trait surface they exercise is +frozen by Phase 1 and the directory layout is reserved by `0002a`. + +The deliverable is a Postgres-feature-gated test and bench suite that catches +regressions before they ship. Single goal: when somebody changes +`storage/postgres/`, `cargo test -p vestige-core --features postgres-backend` +either passes (change is safe) or fails fast with a clear localised error +(change broke something a reviewer can name). + +Scope: + +- Add the testcontainer harness in `tests/phase_2/common/`. +- Add six integration test files, each gated on `postgres-backend`. +- Add the Criterion bench `pg_hybrid_search.rs` with two bench groups. +- Wire dev-dependencies, `[[test]]`, and `[[bench]]` entries in + `crates/vestige-core/Cargo.toml`. +- Document how the suite is run locally and what CI must provide. + +Explicitly NOT in scope: + +- Trait-parity testing (`tests/phase_2/pg_trait_parity.rs` from the master + plan). That file's matrix is delegated to the larger Phase 2 parity push + and is tracked in the master plan's D14; this sub-plan ships six focused + files instead, listed below. +- Concurrency stress tests (`pg_concurrency.rs` from the master plan). + Deferred to a follow-up; the ingest/search code in `0002d`/`0002e` does + not change MVCC semantics, so a dedicated stress test is lower priority + than coverage. +- Re-embed integration tests beyond a smoke check. `0002g` ships its own + unit test against an in-memory plan; an end-to-end re-embed test is + worth a follow-up but not required to call Phase 2 done. + +The six test files in this sub-plan map to the methods most likely to +regress during Phase 2 commits: init/registry, CRUD with the new D7/D8 +columns, search, scheduling, graph, and the SQLite to Postgres migrator. + +--- + +## Prerequisites + +- `0002a` -- `crates/vestige-core/src/storage/postgres/mod.rs` exists, the + `postgres-backend` feature gate is declared, `PgMemoryStore` is a real + type. Method bodies may still be `todo!()` for the parts a given test + does not touch. +- `0002b` -- pool construction works; `PgMemoryStore::connect` and + `PgMemoryStore::from_pool` return real pools. +- `0002c` -- `sqlx::migrate!` wired; tests can call + `PgMemoryStore::run_migrations(&pool).await?` (or whatever the migration + helper ends up named in `0002c`) and reach a populated schema. +- `0002d` -- CRUD, scheduling, and graph method bodies are real (not + `todo!()`). Without `0002d` the CRUD/scheduling/graph tests cannot pass. +- `0002e` -- hybrid search body is real. The search test depends on it. + If `0002e` is not yet merged, the search test file can be stubbed + `#[ignore]` and unignored once `0002e` lands. +- `0002f` -- migrate CLI streaming copy is callable as a library function + (`run_sqlite_to_postgres` or equivalent). The migrate test depends on it + and follows the same stub/unignore pattern if needed. +- Docker or Podman is available at test time. CI must provide it. Local + developers without Docker skip the suite via the runtime check described + below. + +--- + +## Dev-dependencies + +Add `testcontainers` and `testcontainers-modules` as optional dev-deps +gated on the `postgres-backend` feature. `criterion` is already in +dev-dependencies from Phase 1 (`search_bench.rs` uses it). + +From the repo root, run: + +```bash +cargo add --package vestige-core --dev --optional testcontainers@0.22 +cargo add --package vestige-core --dev --optional \ + testcontainers-modules@0.10 --features postgres +cargo add --package vestige-core --dev anyhow +cargo add --package vestige-core --dev tokio --features rt-multi-thread,macros +cargo add --package vestige-core --dev rand@0.8 +``` + +`anyhow` is convenient for the harness's error type (`anyhow::Result<...>` +inside the `common/` helper matches master plan D12). `rand` provides the +deterministic seeded RNG used by the search and migrate tests. `tokio` may +already be in dev-deps via Phase 1 -- run `cargo add` anyway; cargo will +update the features in place rather than duplicate. + +Then mark the testcontainer deps as activated only when the +`postgres-backend` feature is on. Cargo does not have a direct +"dev-dependency required-features" syntax; the convention is to declare the +deps as `optional = true` in `[dev-dependencies]` and reference them inside +the new test files behind `#![cfg(feature = "postgres-backend")]`. The +resulting `Cargo.toml` block looks like: + +```toml +[dev-dependencies] +tempfile = "3" +criterion = { version = "0.5", features = ["html_reports"] } +anyhow = "1" +tokio = { version = "1", features = ["rt-multi-thread", "macros"] } +rand = "0.8" +testcontainers = { version = "0.22", optional = true } +testcontainers-modules = { version = "0.10", features = ["postgres"], optional = true } +``` + +The `optional = true` flag prevents `cargo test` (default features) from +pulling in 30+ MB of testcontainer transitive deps on every contributor +laptop. Activation happens via the `postgres-backend` feature itself; the +test files import `testcontainers::...` only under +`#[cfg(feature = "postgres-backend")]`, so the unused-dep warning is +suppressed by the gate. + +If a future reviewer pushes back on `optional = true` for dev-deps +(rustc/clippy gives `unused_optional_dependency` in some toolchain versions), +the fallback is to drop `optional = true` and accept the dev-dep weight; the +testcontainers crate is dev-only and never ships in a release build either +way. + +--- + +## Test container helper + +**File**: `crates/vestige-core/tests/phase_2/common/mod.rs` + +This is shared infrastructure for every test in `tests/phase_2/`. It is not +its own `[[test]]`; it is a `mod common;` import inside each test file. + +```rust +//! Shared testcontainer setup for Phase 2 Postgres integration tests. +#![cfg(feature = "postgres-backend")] + +use std::sync::Arc; + +use anyhow::Result; +use testcontainers::core::{ContainerPort, IntoContainerPort, WaitFor}; +use testcontainers::runners::AsyncRunner; +use testcontainers::{ContainerAsync, GenericImage, ImageExt}; +use testcontainers_modules::postgres::Postgres; + +use vestige_core::embedder::Embedder; +use vestige_core::storage::postgres::PgMemoryStore; + +/// Spin up a fresh pgvector-enabled Postgres container and return a fully +/// migrated PgMemoryStore connected to it. +/// +/// The ContainerAsync handle is returned alongside the store; callers must +/// keep it alive for the duration of the test. Dropping it tears the +/// container down. +pub async fn fresh_pg_store( + embedder: Arc, +) -> Result<(PgMemoryStore, ContainerAsync)> { + // pgvector/pgvector:pg16 is the official pgvector image built on the + // postgres:16 base. testcontainers-modules::postgres::Postgres targets + // the upstream postgres image by default; we override name + tag. + let container = Postgres::default() + .with_name("pgvector/pgvector") + .with_tag("pg16") + .start() + .await?; + + let port = container.get_host_port_ipv4(5432).await?; + let url = format!("postgresql://postgres:postgres@127.0.0.1:{port}/postgres"); + + // Pool size 4 is enough for tests and stays well below the container's + // default max_connections = 100. + let store = PgMemoryStore::connect(&url, 4).await?; + + // Run migrations. `0002c` decides the exact helper name. The canonical + // call point is whichever is true after that sub-plan; pseudocode here: + store.run_migrations().await?; + + // Register the embedder so the dimension typmod stamp is in place + // before any insert. `0002d` lands the real register_model body. + let sig = embedder.signature(); + store.register_model(&sig).await?; + + Ok((store, container)) +} + +/// Fixed embedder used by every test. Deterministic, no ONNX dependency, +/// returns a 768-dim vector hashed from input text. Lives in +/// `tests/phase_2/common/test_embedder.rs`. +pub use test_embedder::TestEmbedder; + +mod test_embedder; +``` + +**File**: `crates/vestige-core/tests/phase_2/common/test_embedder.rs` + +```rust +//! Deterministic hash-based embedder for tests. +//! +//! Avoids the fastembed/ONNX dependency in CI. Returns a 768-dim vector +//! built from a stable hash of the input text. Two equal strings produce +//! equal vectors; near-equal strings produce near-equal vectors only at +//! the trivial token-overlap level (good enough for a smoke check that +//! the vector pipeline is wired, not a real embedding quality test). +#![cfg(feature = "postgres-backend")] + +use std::sync::Arc; + +use async_trait::async_trait; + +use vestige_core::embedder::{Embedder, EmbedderError, ModelSignature}; + +pub struct TestEmbedder { + pub name: String, + pub dim: usize, +} + +impl TestEmbedder { + pub fn new_768() -> Arc { + Arc::new(Self { name: "test-768".into(), dim: 768 }) + } + pub fn new_1024() -> Arc { + Arc::new(Self { name: "test-1024".into(), dim: 1024 }) + } +} + +#[async_trait] +impl Embedder for TestEmbedder { + fn signature(&self) -> ModelSignature { + ModelSignature { + name: self.name.clone(), + dimension: self.dim, + hash: format!("{}-h", self.name), + } + } + + async fn embed(&self, text: &str) -> Result, EmbedderError> { + let mut v = vec![0.0f32; self.dim]; + let bytes = text.as_bytes(); + for (i, b) in bytes.iter().enumerate() { + v[i % self.dim] += (*b as f32) / 255.0; + } + // Normalize so cosine similarity is meaningful. + let norm: f32 = v.iter().map(|x| x * x).sum::().sqrt(); + if norm > 0.0 { + for x in &mut v { + *x /= norm; + } + } + Ok(v) + } +} +``` + +Notes: + +- The exact `Embedder` trait shape is owned by Phase 1; the example above + may need `embed_batch`, `dimension()`, etc. depending on the frozen + surface. Whoever lands this file mirrors whatever the Phase 1 trait + exposes. +- The container handle is returned, not stored in a `static`. Per-test + isolation matters: one failing test must not leak state into the next. +- A runtime Docker check is added inside `fresh_pg_store` if the + containers can't start: catch the connect error, downgrade it to a + `println!` plus `panic!("docker unreachable; skipping")`, and have each + test use `if docker_available()` to early-return. + +A small helper guards CI environments without Docker: + +```rust +/// Returns Ok if a `docker` or `podman` binary is on PATH and responds. +/// Tests that need a container call this first and `eprintln!`+`return` +/// rather than failing when Docker is absent. +pub fn docker_available() -> bool { + use std::process::Command; + for bin in ["docker", "podman"] { + if Command::new(bin).arg("info").output().map(|o| o.status.success()).unwrap_or(false) { + return true; + } + } + false +} +``` + +Each test starts with: + +```rust +if !common::docker_available() { + eprintln!("docker/podman not available; skipping {}", file!()); + return; +} +``` + +This is preferable to `#[ignore]` because the developer sees the skip in +test output rather than silently passing zero tests. + +--- + +## Six test files + +Each file is at `crates/vestige-core/tests/phase_2/.rs`, declares +`#![cfg(feature = "postgres-backend")]` at the top, imports +`mod common;`, and uses `#[tokio::test(flavor = "multi_thread")]`. + +Each file is also wired as a separate `[[test]]` entry in the Cargo.toml +(see "Cargo.toml" section below). This keeps `cargo test` parallelism +per-file and lets a developer run just one file with +`cargo test --features postgres-backend --test `. + +### 1. `tests/phase_2/init_test.rs` + +**Purpose**: verify the migration pipeline and the embedding registry +behave correctly on first connect, on idempotent reconnect, and on +embedder mismatch. + +**Tests**: + +```rust +#![cfg(feature = "postgres-backend")] + +mod common; +use common::{docker_available, fresh_pg_store, TestEmbedder}; + +#[tokio::test(flavor = "multi_thread")] +async fn migrations_apply_cleanly() { + if !docker_available() { eprintln!("docker unavailable; skip"); return; } + let embedder = TestEmbedder::new_768(); + let (_store, _container) = fresh_pg_store(embedder).await.unwrap(); + // If we reached here, sqlx::migrate! ran 0001_init + 0002_hnsw without + // error against a fresh pgvector container. +} + +#[tokio::test(flavor = "multi_thread")] +async fn registry_persists_after_first_connect() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _container) = fresh_pg_store(embedder.clone()).await.unwrap(); + let registered = store.registered_model().await.unwrap(); + assert!(registered.is_some()); + let sig = registered.unwrap(); + assert_eq!(sig.name, "test-768"); + assert_eq!(sig.dimension, 768); +} + +#[tokio::test(flavor = "multi_thread")] +async fn second_connect_with_same_embedder_is_idempotent() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store_a, container) = fresh_pg_store(embedder.clone()).await.unwrap(); + // Reuse the same container, build a second store against the same URL, + // call register_model again. Must not error. + let port = container.get_host_port_ipv4(5432).await.unwrap(); + let url = format!("postgresql://postgres:postgres@127.0.0.1:{port}/postgres"); + let store_b = vestige_core::storage::postgres::PgMemoryStore::connect(&url, 4).await.unwrap(); + store_b.register_model(&embedder.signature()).await.unwrap(); + assert_eq!( + store_a.registered_model().await.unwrap().unwrap().name, + store_b.registered_model().await.unwrap().unwrap().name, + ); +} + +#[tokio::test(flavor = "multi_thread")] +async fn second_connect_with_different_embedder_returns_mismatch() { + if !docker_available() { return; } + let e768 = TestEmbedder::new_768(); + let (_store, container) = fresh_pg_store(e768).await.unwrap(); + let port = container.get_host_port_ipv4(5432).await.unwrap(); + let url = format!("postgresql://postgres:postgres@127.0.0.1:{port}/postgres"); + let store2 = vestige_core::storage::postgres::PgMemoryStore::connect(&url, 4).await.unwrap(); + let e1024 = TestEmbedder::new_1024(); + let err = store2.register_model(&e1024.signature()).await; + assert!(matches!(err, Err(vestige_core::storage::MemoryStoreError::EmbeddingMismatch { .. }))); +} +``` + +### 2. `tests/phase_2/crud_test.rs` + +**Purpose**: insert + get + update + delete round-trip; non-existent id +returns `Ok(None)`; D7+D8 columns (`owner_user_id`, `visibility`, +`shared_with_groups`, `codebase`) round-trip correctly. + +**Tests**: + +```rust +#![cfg(feature = "postgres-backend")] + +mod common; +use common::{docker_available, fresh_pg_store, TestEmbedder}; +use vestige_core::memory::{MemoryRecord, Visibility}; +use uuid::Uuid; + +#[tokio::test(flavor = "multi_thread")] +async fn insert_get_update_delete_roundtrip() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _container) = fresh_pg_store(embedder.clone()).await.unwrap(); + + let mut rec = MemoryRecord::new("hello world"); + rec.tags = vec!["test".into(), "crud".into()]; + rec.embedding = Some(embedder.embed(&rec.content).await.unwrap()); + let id = store.insert(&rec).await.unwrap(); + + let got = store.get(&id).await.unwrap().unwrap(); + assert_eq!(got.content, "hello world"); + assert_eq!(got.tags, vec!["test", "crud"]); + + let mut updated = got.clone(); + updated.content = "hello updated".into(); + updated.embedding = Some(embedder.embed("hello updated").await.unwrap()); + store.update(&updated).await.unwrap(); + let after = store.get(&id).await.unwrap().unwrap(); + assert_eq!(after.content, "hello updated"); + + store.delete(&id).await.unwrap(); + assert!(store.get(&id).await.unwrap().is_none()); +} + +#[tokio::test(flavor = "multi_thread")] +async fn get_nonexistent_returns_ok_none() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _container) = fresh_pg_store(embedder).await.unwrap(); + let missing = Uuid::new_v4(); + assert!(store.get(&missing).await.unwrap().is_none()); +} + +#[tokio::test(flavor = "multi_thread")] +async fn update_nonexistent_returns_not_found() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _container) = fresh_pg_store(embedder.clone()).await.unwrap(); + let mut rec = MemoryRecord::new("ghost"); + rec.id = Uuid::new_v4(); + rec.embedding = Some(embedder.embed("ghost").await.unwrap()); + // Contract: update on a missing id is Err(NotFound) or Ok with + // rows_updated == 0. Whichever 0002d picks is what this test asserts. + let res = store.update(&rec).await; + // Adjust to actual contract once 0002d lands: + assert!(res.is_err() || res.is_ok()); +} + +#[tokio::test(flavor = "multi_thread")] +async fn d7_d8_columns_roundtrip() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _container) = fresh_pg_store(embedder.clone()).await.unwrap(); + + let owner = Uuid::parse_str("00000000-0000-0000-0000-000000000001").unwrap(); + let group_a = Uuid::new_v4(); + let group_b = Uuid::new_v4(); + + let mut rec = MemoryRecord::new("contextful"); + rec.owner_user_id = owner; + rec.visibility = Visibility::Group; + rec.shared_with_groups = vec![group_a, group_b]; + rec.codebase = Some("vestige".to_string()); + rec.embedding = Some(embedder.embed(&rec.content).await.unwrap()); + + let id = store.insert(&rec).await.unwrap(); + let got = store.get(&id).await.unwrap().unwrap(); + + assert_eq!(got.owner_user_id, owner); + assert_eq!(got.visibility, Visibility::Group); + assert_eq!(got.shared_with_groups, vec![group_a, group_b]); + assert_eq!(got.codebase.as_deref(), Some("vestige")); +} +``` + +### 3. `tests/phase_2/search_test.rs` + +**Purpose**: exercise the three search modes (fts only, vector only, +hybrid), then the domain/tag/node_type/min_retrievability filters, then +the empty-query edge case. + +**Tests**: + +```rust +#![cfg(feature = "postgres-backend")] + +mod common; +use common::{docker_available, fresh_pg_store, TestEmbedder}; +use vestige_core::memory::MemoryRecord; +use vestige_core::storage::SearchQuery; + +async fn seed(store: &impl vestige_core::storage::MemoryStore, embedder: &(impl vestige_core::embedder::Embedder + ?Sized)) { + let seeds: &[(&str, &[&str], &str)] = &[ + ("rust async trait", &["rust", "async"], "code"), + ("postgres hnsw vector", &["postgres", "vector"], "code"), + ("fastembed onnx model", &["embeddings", "onnx"], "model"), + ("breakfast tacos recipe", &["food"], "note"), + ("morning bike commute", &["health"], "event"), + ]; + for (text, tags, node_type) in seeds { + let mut r = MemoryRecord::new(*text); + r.tags = tags.iter().map(|s| s.to_string()).collect(); + r.node_type = node_type.to_string(); + r.embedding = Some(embedder.embed(text).await.unwrap()); + store.insert(&r).await.unwrap(); + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn fts_only_returns_keyword_matches() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + seed(&store, embedder.as_ref()).await; + + let q = SearchQuery { text: Some("rust".into()), embedding: None, limit: 10, ..Default::default() }; + let hits = store.search(&q).await.unwrap(); + assert!(hits.iter().any(|h| h.content.contains("rust async trait"))); +} + +#[tokio::test(flavor = "multi_thread")] +async fn vector_only_returns_semantic_matches() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + seed(&store, embedder.as_ref()).await; + + let qe = embedder.embed("vector search").await.unwrap(); + let q = SearchQuery { text: None, embedding: Some(qe), limit: 10, ..Default::default() }; + let hits = store.search(&q).await.unwrap(); + assert!(!hits.is_empty()); +} + +#[tokio::test(flavor = "multi_thread")] +async fn hybrid_returns_rrf_fused_results() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + seed(&store, embedder.as_ref()).await; + + let qe = embedder.embed("postgres vector").await.unwrap(); + let q = SearchQuery { + text: Some("postgres".into()), + embedding: Some(qe), + limit: 10, + ..Default::default() + }; + let hits = store.search(&q).await.unwrap(); + let top = hits.first().unwrap(); + assert!(top.content.contains("postgres")); + // RRF score must be at least the floor of two contributions at rank 0. + assert!(top.score >= 1.0 / 61.0); +} + +#[tokio::test(flavor = "multi_thread")] +async fn filter_by_tag_and_node_type() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + seed(&store, embedder.as_ref()).await; + + let q = SearchQuery { + text: Some("model".into()), + tags: vec!["embeddings".into()], + node_type: Some("model".into()), + limit: 10, + ..Default::default() + }; + let hits = store.search(&q).await.unwrap(); + assert!(hits.iter().all(|h| h.tags.contains(&"embeddings".into()))); + assert!(hits.iter().all(|h| h.node_type == "model")); +} + +#[tokio::test(flavor = "multi_thread")] +async fn min_retrievability_filter() { + // After 0002e ships the filter wiring this exercises it. For now, + // assert the empty / pass-through case: min_retrievability = 0.0 + // returns all results. + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + seed(&store, embedder.as_ref()).await; + + let q = SearchQuery { text: Some("rust".into()), min_retrievability: 0.0, limit: 10, ..Default::default() }; + let hits = store.search(&q).await.unwrap(); + assert!(!hits.is_empty()); +} + +#[tokio::test(flavor = "multi_thread")] +async fn empty_query_returns_ok_empty_or_all() { + // Contract chosen in 0002e; this test asserts whichever it picks. + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder).await.unwrap(); + let q = SearchQuery { text: None, embedding: None, limit: 10, ..Default::default() }; + let hits = store.search(&q).await.unwrap(); + let _ = hits; // assert is intentionally weak until 0002e fixes the contract +} +``` + +### 4. `tests/phase_2/scheduling_test.rs` + +**Purpose**: FSRS state round-trip via `get_scheduling` / +`update_scheduling` with `ON CONFLICT DO UPDATE` semantics, and +`get_due_memories` paging. + +**Tests**: + +```rust +#![cfg(feature = "postgres-backend")] + +mod common; +use common::{docker_available, fresh_pg_store, TestEmbedder}; +use chrono::{Duration, Utc}; +use vestige_core::memory::MemoryRecord; +use vestige_core::scheduling::SchedulingState; + +#[tokio::test(flavor = "multi_thread")] +async fn scheduling_update_and_get_roundtrip() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + + let mut rec = MemoryRecord::new("fsrs target"); + rec.embedding = Some(embedder.embed("fsrs target").await.unwrap()); + let id = store.insert(&rec).await.unwrap(); + + let s = SchedulingState { + memory_id: id, + stability: 2.5, + difficulty: 6.7, + reps: 1, + lapses: 0, + next_review: Utc::now() + Duration::days(1), + last_review: Some(Utc::now()), + }; + store.update_scheduling(&s).await.unwrap(); + + let back = store.get_scheduling(&id).await.unwrap().unwrap(); + assert!((back.stability - 2.5).abs() < 1e-6); + assert_eq!(back.reps, 1); +} + +#[tokio::test(flavor = "multi_thread")] +async fn scheduling_on_conflict_overwrites() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + + let mut rec = MemoryRecord::new("repeating"); + rec.embedding = Some(embedder.embed("repeating").await.unwrap()); + let id = store.insert(&rec).await.unwrap(); + + for reps in [1u32, 2, 3] { + let s = SchedulingState { + memory_id: id, + stability: reps as f32, + difficulty: 5.0, + reps, + lapses: 0, + next_review: Utc::now() + Duration::days(reps as i64), + last_review: Some(Utc::now()), + }; + store.update_scheduling(&s).await.unwrap(); + } + let final_state = store.get_scheduling(&id).await.unwrap().unwrap(); + assert_eq!(final_state.reps, 3); +} + +#[tokio::test(flavor = "multi_thread")] +async fn get_due_memories_pages() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + + let now = Utc::now(); + // Insert 25 due memories with next_review in the past. + for i in 0..25 { + let mut rec = MemoryRecord::new(format!("due {i}")); + rec.embedding = Some(embedder.embed(&rec.content).await.unwrap()); + let id = store.insert(&rec).await.unwrap(); + let s = SchedulingState { + memory_id: id, + stability: 1.0, + difficulty: 5.0, + reps: 1, + lapses: 0, + next_review: now - Duration::hours(i as i64 + 1), + last_review: Some(now - Duration::hours(i as i64 + 2)), + }; + store.update_scheduling(&s).await.unwrap(); + } + let page1 = store.get_due_memories(now, 10, 0).await.unwrap(); + let page2 = store.get_due_memories(now, 10, 10).await.unwrap(); + let page3 = store.get_due_memories(now, 10, 20).await.unwrap(); + assert_eq!(page1.len(), 10); + assert_eq!(page2.len(), 10); + assert_eq!(page3.len(), 5); +} +``` + +### 5. `tests/phase_2/graph_test.rs` + +**Purpose**: `add_edge`, `get_edges`, `remove_edge`, and `get_neighbors` +with a non-trivial depth. + +**Tests**: + +```rust +#![cfg(feature = "postgres-backend")] + +mod common; +use common::{docker_available, fresh_pg_store, TestEmbedder}; +use vestige_core::memory::MemoryRecord; +use vestige_core::storage::Edge; + +async fn insert_n(store: &impl vestige_core::storage::MemoryStore, embedder: &(impl vestige_core::embedder::Embedder + ?Sized), n: usize) -> Vec { + let mut ids = Vec::with_capacity(n); + for i in 0..n { + let mut r = MemoryRecord::new(format!("node {i}")); + r.embedding = Some(embedder.embed(&r.content).await.unwrap()); + ids.push(store.insert(&r).await.unwrap()); + } + ids +} + +#[tokio::test(flavor = "multi_thread")] +async fn add_get_remove_edge() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + let ids = insert_n(&store, embedder.as_ref(), 3).await; + + let e = Edge { + source_id: ids[0], + target_id: ids[1], + edge_type: "semantic".into(), + strength: 0.8, + activation_count: 0, + created_at: chrono::Utc::now(), + last_activated: None, + }; + store.add_edge(&e).await.unwrap(); + + let edges = store.get_edges(&ids[0]).await.unwrap(); + assert_eq!(edges.len(), 1); + assert_eq!(edges[0].target_id, ids[1]); + + store.remove_edge(&ids[0], &ids[1], "semantic").await.unwrap(); + assert!(store.get_edges(&ids[0]).await.unwrap().is_empty()); +} + +#[tokio::test(flavor = "multi_thread")] +async fn get_neighbors_with_depth() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + let (store, _c) = fresh_pg_store(embedder.clone()).await.unwrap(); + let ids = insert_n(&store, embedder.as_ref(), 5).await; + + // Chain: 0 -> 1 -> 2 -> 3 -> 4 + for w in ids.windows(2) { + let e = Edge { + source_id: w[0], + target_id: w[1], + edge_type: "semantic".into(), + strength: 1.0, + activation_count: 0, + created_at: chrono::Utc::now(), + last_activated: None, + }; + store.add_edge(&e).await.unwrap(); + } + + let depth_1 = store.get_neighbors(&ids[0], 1).await.unwrap(); + let depth_2 = store.get_neighbors(&ids[0], 2).await.unwrap(); + let depth_4 = store.get_neighbors(&ids[0], 4).await.unwrap(); + + assert_eq!(depth_1.len(), 1); + assert_eq!(depth_2.len(), 2); + assert_eq!(depth_4.len(), 4); +} +``` + +### 6. `tests/phase_2/migrate_test.rs` + +**Purpose**: seed SQLite with a small dataset, run the migrator, verify +counts and a sample row. + +**Tests**: + +```rust +#![cfg(feature = "postgres-backend")] + +mod common; +use common::{docker_available, fresh_pg_store, TestEmbedder}; +use vestige_core::memory::MemoryRecord; +use vestige_core::storage::{SqliteMemoryStore, MemoryStore}; +use vestige_core::storage::postgres::migrate_cli::run_sqlite_to_postgres; + +#[tokio::test(flavor = "multi_thread")] +async fn sqlite_to_postgres_small_corpus() { + if !docker_available() { return; } + let embedder = TestEmbedder::new_768(); + + // Seed SQLite (in-memory or tempfile). + let tmp = tempfile::tempdir().unwrap(); + let sqlite_path = tmp.path().join("seed.db"); + let sqlite = SqliteMemoryStore::new(&sqlite_path).unwrap(); + sqlite.register_model(&embedder.signature()).await.unwrap(); + for i in 0..50 { + let mut r = MemoryRecord::new(format!("seed row {i}")); + r.tags = vec![format!("tag-{}", i % 3)]; + r.embedding = Some(embedder.embed(&r.content).await.unwrap()); + sqlite.insert(&r).await.unwrap(); + } + + // Spin up Postgres and migrate. + let (pg, _container) = fresh_pg_store(embedder.clone()).await.unwrap(); + let report = run_sqlite_to_postgres(&sqlite, &pg, embedder.clone()).await.unwrap(); + + assert_eq!(report.memories_copied, 50); + assert_eq!(pg.count().await.unwrap(), 50); + + // Spot-check a sample row. + let sample_id = sqlite.list_ids(1, 0).await.unwrap()[0]; + let from_sqlite = sqlite.get(&sample_id).await.unwrap().unwrap(); + let from_pg = pg.get(&sample_id).await.unwrap().unwrap(); + assert_eq!(from_sqlite.content, from_pg.content); + assert_eq!(from_sqlite.tags, from_pg.tags); +} +``` + +If `0002f` is not yet merged when this sub-plan executes, the test file is +still added but the body sits behind `#[ignore = "depends on 0002f"]`, +removed once `0002f` lands. + +--- + +## How tests are run + +```bash +# Run all six phase_2 integration tests: +cargo test -p vestige-core --features postgres-backend --test '*' + +# Run a single file: +cargo test -p vestige-core --features postgres-backend --test init_test +cargo test -p vestige-core --features postgres-backend --test crud_test +cargo test -p vestige-core --features postgres-backend --test search_test +cargo test -p vestige-core --features postgres-backend --test scheduling_test +cargo test -p vestige-core --features postgres-backend --test graph_test +cargo test -p vestige-core --features postgres-backend --test migrate_test + +# SQLite-only sanity check (must continue to pass, Phase 1 unchanged): +cargo test -p vestige-core +``` + +Requirements: + +- Docker or Podman must be reachable. `testcontainers` connects via the + default Docker socket (`/var/run/docker.sock` on Linux, `~/.docker/run/docker.sock` + or the Docker Desktop socket on macOS, the Podman REST socket if + `DOCKER_HOST` points there). +- On a developer machine without Docker, the suite skips at runtime via + the `docker_available()` check in `common/mod.rs`. The test output + includes a `docker unavailable; skip` line per test so the developer + knows the tests were not silently dropped. +- The pgvector image (`pgvector/pgvector:pg16`) is pulled on first run; + ~200 MB. A pre-pulled image keeps the per-run overhead at the cold-start + container boot (~2-5 seconds). + +--- + +## Benches + +**File**: `crates/vestige-core/benches/pg_hybrid_search.rs` + +Two Criterion benches: `search_1k` and `search_100k`. Both gated on the +`postgres-backend` feature via `required-features` in the bench entry and +via a top-of-file `#![cfg(feature = "postgres-backend")]`. + +```rust +//! Criterion benches for the Postgres backend's hybrid RRF search. +#![cfg(feature = "postgres-backend")] + +use std::sync::Arc; +use std::sync::OnceLock; + +use criterion::{black_box, criterion_group, criterion_main, Criterion}; +use rand::{rngs::StdRng, Rng, SeedableRng}; +use testcontainers::runners::AsyncRunner; +use testcontainers::{ContainerAsync, ImageExt}; +use testcontainers_modules::postgres::Postgres; +use tokio::runtime::Runtime; + +use vestige_core::embedder::Embedder; +use vestige_core::memory::MemoryRecord; +use vestige_core::storage::postgres::PgMemoryStore; +use vestige_core::storage::{MemoryStore, SearchQuery}; + +// Bench fixture lives in tests/phase_2/common/test_embedder.rs; +// duplicate the type here under benches/ so the bench compiles without +// depending on tests/. +mod test_embedder; +use test_embedder::TestEmbedder; + +struct Bench { + rt: Runtime, + store: PgMemoryStore, + embedder: Arc, + _container: ContainerAsync, + query_embedding: Vec, +} + +async fn build_bench(rows: usize) -> Bench { + let rt_handle = tokio::runtime::Handle::current(); + let _ = rt_handle; // proves we are inside an executor + let embedder = TestEmbedder::new_768(); + let container = Postgres::default() + .with_name("pgvector/pgvector") + .with_tag("pg16") + .start() + .await + .unwrap(); + let port = container.get_host_port_ipv4(5432).await.unwrap(); + let url = format!("postgresql://postgres:postgres@127.0.0.1:{port}/postgres"); + let store = PgMemoryStore::connect(&url, 8).await.unwrap(); + store.run_migrations().await.unwrap(); + store.register_model(&embedder.signature()).await.unwrap(); + + let mut rng = StdRng::seed_from_u64(0xc0ffee); + let vocab = [ + "rust", "postgres", "vector", "hnsw", "fastembed", "onnx", + "search", "memory", "fsrs", "consolidate", "graph", "edge", + "async", "trait", "tokio", "sqlx", "pgvector", "embedding", + ]; + for i in 0..rows { + let words: String = (0..8) + .map(|_| vocab[rng.gen_range(0..vocab.len())]) + .collect::>() + .join(" "); + let mut r = MemoryRecord::new(format!("{i}: {words}")); + r.tags = vec![format!("tag-{}", i % 7)]; + r.embedding = Some(embedder.embed(&r.content).await.unwrap()); + store.insert(&r).await.unwrap(); + } + let query_embedding = embedder.embed("postgres vector search").await.unwrap(); + Bench { + rt: tokio::runtime::Runtime::new().unwrap(), + store, + embedder, + _container: container, + query_embedding, + } +} + +fn bench_search_1k(c: &mut Criterion) { + let rt = tokio::runtime::Runtime::new().unwrap(); + let bench = rt.block_on(build_bench(1_000)); + c.bench_function("pg_search_1k", |b| { + b.iter(|| { + let q = SearchQuery { + text: Some("postgres vector".into()), + embedding: Some(bench.query_embedding.clone()), + limit: 10, + ..Default::default() + }; + let hits = bench.rt.block_on(bench.store.search(&q)).unwrap(); + black_box(hits); + }) + }); +} + +// Heavy: 100k rows; seed time runs into minutes. Gated by an env var so +// `cargo bench --features postgres-backend --bench pg_hybrid_search` does +// not pay the cost by default. +fn bench_search_100k(c: &mut Criterion) { + if std::env::var("VESTIGE_BENCH_HEAVY").is_err() { + eprintln!("skip pg_search_100k (set VESTIGE_BENCH_HEAVY=1 to enable)"); + return; + } + let rt = tokio::runtime::Runtime::new().unwrap(); + let bench = rt.block_on(build_bench(100_000)); + c.bench_function("pg_search_100k", |b| { + b.iter(|| { + let q = SearchQuery { + text: Some("postgres vector".into()), + embedding: Some(bench.query_embedding.clone()), + limit: 10, + ..Default::default() + }; + let hits = bench.rt.block_on(bench.store.search(&q)).unwrap(); + black_box(hits); + }) + }); +} + +criterion_group!(benches, bench_search_1k, bench_search_100k); +criterion_main!(benches); +``` + +**File**: `crates/vestige-core/benches/test_embedder.rs` + +Duplicate of `tests/phase_2/common/test_embedder.rs`. Cargo's bench target +cannot `mod` into `tests/`; the duplication is the standard fix. Keep both +files in sync; if either grows non-trivially, refactor into a shared +`pub(crate)` module under `src/embedder/test_support.rs` gated on +`#[cfg(any(test, feature = "test-support"))]`. + +`VESTIGE_BENCH_HEAVY` gate: the 100k seed step takes several minutes (one +`INSERT` per row plus HNSW upsert). Skipping by default keeps `cargo bench` +under a minute for the 1k bench. Document this gate in the runbook +(`0002i`). + +--- + +## Cargo.toml + +Final state of the relevant sections of +`crates/vestige-core/Cargo.toml` after this sub-plan lands: + +```toml +[dev-dependencies] +tempfile = "3" +criterion = { version = "0.5", features = ["html_reports"] } +anyhow = "1" +tokio = { version = "1", features = ["rt-multi-thread", "macros"] } +rand = "0.8" +testcontainers = { version = "0.22", optional = true } +testcontainers-modules = { version = "0.10", features = ["postgres"], optional = true } + +[[bench]] +name = "search_bench" +harness = false + +[[bench]] +name = "pg_hybrid_search" +harness = false +required-features = ["postgres-backend"] + +[[test]] +name = "init_test" +path = "tests/phase_2/init_test.rs" +required-features = ["postgres-backend"] + +[[test]] +name = "crud_test" +path = "tests/phase_2/crud_test.rs" +required-features = ["postgres-backend"] + +[[test]] +name = "search_test" +path = "tests/phase_2/search_test.rs" +required-features = ["postgres-backend"] + +[[test]] +name = "scheduling_test" +path = "tests/phase_2/scheduling_test.rs" +required-features = ["postgres-backend"] + +[[test]] +name = "graph_test" +path = "tests/phase_2/graph_test.rs" +required-features = ["postgres-backend"] + +[[test]] +name = "migrate_test" +path = "tests/phase_2/migrate_test.rs" +required-features = ["postgres-backend"] +``` + +Notes: + +- `required-features = ["postgres-backend"]` on each `[[test]]` ensures + the file is only built (and only counted by `cargo test`) when the + feature is on. Cargo silently skips it otherwise -- exactly the desired + behavior for default `cargo test` runs. +- The benches use the same `required-features` shape so default + `cargo bench` is unaffected. + +--- + +## CI considerations + +- GitHub Actions / Forgejo Actions runners need Docker available. Default + `ubuntu-latest` runners include Docker. Self-hosted Forgejo runners on + TFGrid VMs must install `docker.io` or run `podman` with the Docker + socket compatibility shim. Document the runner requirement in the + runbook (`0002i`). +- The Postgres feature tests should run in a separate CI matrix entry to + isolate failures and skip them entirely on platforms (Windows runners + if any) where the pgvector image is not available. +- Cache the `pgvector/pgvector:pg16` image between runs. The + `docker/setup-buildx-action` cache or a simple `docker pull` step before + the test step keeps cold-start under the existing CI time budget. +- Skip CI: contributors without Docker can still merge changes that do + not touch `storage/postgres/`. The pre-merge required check is "phase_2 + tests pass on the runner with Docker"; the local pre-commit hook does + not gate on it. +- Bench CI: do not run `pg_search_100k` in regular CI; only run it + manually or on a scheduled weekly job and post results to the PR + description / ADR comment trail. + +Recommended CI job shape (sketch): + +```yaml +jobs: + postgres-tests: + runs-on: ubuntu-latest + services: + # no `postgres` service block needed; testcontainers manages its own + steps: + - uses: actions/checkout@v4 + - run: docker pull pgvector/pgvector:pg16 + - uses: dtolnay/rust-toolchain@stable + - run: cargo test -p vestige-core --features postgres-backend --test '*' +``` + +--- + +## Verification + +After all files are in place: + +```bash +# Default build still clean (no postgres deps pulled in): +cargo build -p vestige-core +cargo test -p vestige-core + +# Postgres feature build + integration tests: +cargo build -p vestige-core --features postgres-backend +cargo test -p vestige-core --features postgres-backend + +# Just the new tests: +cargo test -p vestige-core --features postgres-backend --test '*' + +# Quick bench sanity check (1k only): +cargo bench -p vestige-core --features postgres-backend --bench pg_hybrid_search -- --quick + +# Heavy bench (manual, multi-minute seed step): +VESTIGE_BENCH_HEAVY=1 cargo bench -p vestige-core \ + --features postgres-backend \ + --bench pg_hybrid_search -- --quick + +# Clippy with everything on: +cargo clippy -p vestige-core --features postgres-backend --all-targets -- -D warnings +``` + +Expected results: + +- Default build is unchanged; no testcontainers deps in `Cargo.lock`'s + default resolution. +- With `--features postgres-backend`, all six integration tests pass on a + machine with Docker available, or each prints `docker unavailable; skip` + and exits 0. +- `cargo bench ... -- --quick` produces a `pg_search_1k` line with a + p50 below the master plan's 10 ms target on a developer laptop (looser + on a CI runner -- the target is informative, not gated). + +--- + +## Acceptance criteria + +- [ ] `crates/vestige-core/tests/phase_2/common/mod.rs` and + `test_embedder.rs` exist and compile under + `--features postgres-backend`. +- [ ] All six integration test files exist, each with + `#![cfg(feature = "postgres-backend")]` at the top. +- [ ] Each test file has a corresponding `[[test]]` entry in + `Cargo.toml` with `required-features = ["postgres-backend"]`. +- [ ] `crates/vestige-core/benches/pg_hybrid_search.rs` exists with + `search_1k` and `search_100k` benches, the latter gated on + `VESTIGE_BENCH_HEAVY`. +- [ ] `[[bench]] name = "pg_hybrid_search"` entry present with + `required-features = ["postgres-backend"]`. +- [ ] `testcontainers@0.22` and `testcontainers-modules@0.10` with the + `postgres` feature are in `[dev-dependencies]` of `vestige-core`. +- [ ] `anyhow`, `tokio`, `rand` are in `[dev-dependencies]`. +- [ ] `cargo build -p vestige-core` (default features) is unchanged: no + testcontainers in the build graph; no new warnings. +- [ ] `cargo test -p vestige-core` (default features) passes with no + changes to the Phase 1 test count beyond what `0002a..g` already + moved. +- [ ] `cargo test -p vestige-core --features postgres-backend --test '*'` + passes on a runner with Docker available, or skips cleanly with the + `docker unavailable; skip` lines. +- [ ] `cargo bench -p vestige-core --features postgres-backend + --bench pg_hybrid_search -- --quick` runs `pg_search_1k` to + completion and does NOT run `pg_search_100k` unless + `VESTIGE_BENCH_HEAVY=1`. +- [ ] `cargo clippy -p vestige-core --features postgres-backend + --all-targets -- -D warnings` is clean. +- [ ] The runbook (`0002i`) gets a one-paragraph "How to run the test + suite locally" callout referring back to this sub-plan's + "Verification" section. (`0002i` is owned separately; this sub-plan + just lists the dependency.) + +--- + +## Open questions for the implementer + +1. **Migration helper name.** `0002c` decides whether + `PgMemoryStore::run_migrations(&self)` or + `vestige_core::storage::postgres::migrations::run(&pool)` is the public + call. Update `common/mod.rs` to match. +2. **Update-on-missing contract.** `0002d` decides whether + `MemoryStore::update` returns `Err(NotFound)` or `Ok(())` with zero + affected rows when the id does not exist. The CRUD test stub here + accepts either; tighten the assert once the contract is fixed. +3. **Empty-query search contract.** `0002e` decides whether + `SearchQuery { text: None, embedding: None }` is `Ok(empty)` or an + error. Same tightening pattern as #2. +4. **Pool size for 100k bench.** Current value is 8; if the bench + bottlenecks on the pool, tune up to 16 or 32 and document in the + bench file's leading doc comment. +5. **Shared `TestEmbedder` location.** Currently duplicated between + `tests/phase_2/common/test_embedder.rs` and + `benches/test_embedder.rs`. If duplication bothers a reviewer, lift to + `crates/vestige-core/src/embedder/test_support.rs` behind a + `test-support` Cargo feature pulled in by both `tests` and `benches`. + Out of scope for this sub-plan; record as a follow-up. diff --git a/docs/plans/0002i-runbook.md b/docs/plans/0002i-runbook.md new file mode 100644 index 0000000..f63694f --- /dev/null +++ b/docs/plans/0002i-runbook.md @@ -0,0 +1,724 @@ +# Phase 2 Sub-Plan 0002i -- Postgres Ops Runbook + +**Status**: Ready +**Depends on**: Phase 2 sub-plans 0002a through 0002h merged (or at least +their interfaces stable). The runbook documents behaviour produced by those +sub-plans: feature gate, config schema, migrations, `vestige migrate` CLI, +hybrid search, and the test harness. Nothing in this sub-plan compiles or +runs; the deliverable is a single Markdown file. + +This sub-plan covers Phase 2 master-plan deliverable D16 only: a one-page +operator-facing runbook for deploying Vestige with the Postgres backend. + +--- + +## Context + +Why a runbook. The ADR (0002) and the master plan (0002) are written for +implementors. They settle execution-level decisions and itemise deliverables. +They are not deployable instructions. A separate document is needed for the +operator who has to install pgvector, take backups, recover from a failed +re-embed, and decide whether to roll a migration back. The runbook is that +document. + +Who reads it. Ops people, not developers. Concretely: someone who has a +shell on a Linux host, knows how to use `psql` and `systemctl`, and has been +handed a built `vestige-mcp` binary plus a `vestige.toml`. They are not +expected to read Rust source or follow internal Cargo features. They do +know what a backup is, what a connection pool is, and how to read a +PostgreSQL log. + +In scope: deployment of the Postgres backend on a single host or a small +cluster, day-to-day monitoring, scheduled and ad-hoc backups, embedding +migration via `vestige migrate reembed`, and troubleshooting the failure +modes most likely to land in an operator's lap. + +Out of scope: local development setup -- that lives in +`docs/plans/local-dev-postgres-setup.md` and the runbook links to it for +developer onboarding only. Network exposure of the Vestige HTTP API +(Phase 3), federation (Phase 5), Postgres TLS / certificate handling, and +multi-tenant operation are also out of scope; the runbook explicitly +flags them as "see Phase N" so operators do not improvise. + +This sub-plan is the plan for producing the runbook. It outlines the +runbook structure, inlines the runbook body as the canonical "this is what +the file should say" text, and lists acceptance criteria. The implementation +agent for D16 copies the inlined body into `docs/runbook/postgres.md`, +creating `docs/runbook/` if it does not already exist. No other files in the +repository are modified. + +--- + +## Deliverable + +The artifact produced by executing this sub-plan is exactly one new file: + +``` +docs/runbook/postgres.md +``` + +It is NOT under `docs/plans/`. Plans describe how Vestige gets built; +runbooks describe how Vestige gets operated. The two directories are +deliberately separated. + +Side effect: create the directory `docs/runbook/` if it does not exist. +Do not add an index file, README, or any other content under `docs/runbook/` +in this sub-plan -- only `postgres.md`. + +This sub-plan document (`docs/plans/0002i-runbook.md`) is itself NOT a +deliverable in the operator sense. It is the plan for producing the runbook, +and lives under `docs/plans/` with the other Phase 2 sub-plans. + +--- + +## Runbook structure + +The runbook is organised as a flat list of ten sections, in order. Operators +read it top to bottom on first deployment; subsequent visits jump to a +specific section. Section numbering matches the inlined body below. + +1. **Prerequisites** -- what must already be installed and available on the + host before Vestige even tries to connect. PostgreSQL 16 or newer + (18 on Arch is fine), pgvector >= 0.5, pgcrypto (for `gen_random_uuid`), + sufficient disk for the HNSW index, OS user permissions on the data + directory. + +2. **Initial setup** -- one-time tasks: create the database role, create + the database, install required extensions, and lay down an initial + `vestige.toml`. Includes the canonical `CREATE EXTENSION` calls and a + minimal config snippet. + +3. **First connect** -- what happens the first time `vestige-mcp` starts + against an empty `vestige` database: sqlx applies the bundled + migrations, `register_model` stamps the embedding column type, and the + registry row is written. How an operator verifies each step succeeded + using `psql`. + +4. **Connection pool tuning** -- default of 10 connections per + `vestige-mcp` instance, when to raise it, how to size the Postgres + server-side `max_connections` and `shared_buffers` accordingly. Cross- + reference to `vestige.toml` and to ADR 0002 D2 / open question Q5. + +5. **Backup discipline** -- `pg_dump` and `pg_restore` invocations, + recommended frequency, which tables matter (knowledge_nodes and scheduling + are critical and not regenerable; review_events is append-only and + replayable from clients; edges are reconstructable from spreading + activation runs; domains can be recomputed by Phase 4 once it ships). + Also covers backup verification (restore-to-tmp drill). + +6. **Migration between embeddings** -- the `vestige migrate reembed` + workflow: when an operator needs it (model upgrade, dim change), + downtime expectations, how to verify completion via the + `embedding_model` registry and HNSW presence, and how to recover from + an interrupted run. + +7. **Re-clustering domains** -- a brief forward reference. Domain + clustering is owned by Phase 4 (`docs/plans/0004-phase-4-emergent-domain-classification.md`); + until Phase 4 ships, operators should not invoke any re-clustering + workflow manually. The runbook section is intentionally one paragraph + long and points at the Phase 4 plan. + +8. **Monitoring** -- the small set of pg_catalog and pg_stat_* queries + that answer "is Vestige healthy?": `pg_stat_activity` for stuck queries, + `pg_stat_statements` for query patterns (if the extension is enabled), + index sizes for the HNSW, and how to spot a half-built HNSW after a + failed migration. + +9. **Troubleshooting** -- a table of common errors with the symptom and + the fix. Extension missing, pool exhausted, embedding dimension + mismatch, FTS language config (`'english'` vs `'simple'`), migrations + partially applied. + +10. **Rollback caveats** -- every `*.up.sql` has a `*.down.sql`, but + downgrades destroy data (HNSW gets dropped, vector column type + reverts, domain rows vanish). The runbook tells operators to always + take a backup before applying a new migration, even though sqlx will + do its best to be idempotent. + +--- + +## Runbook body + +The full text below is what should be copied verbatim into +`docs/runbook/postgres.md`. ASCII only. Code blocks use fenced syntax with +language hints. Operator-facing prose; second person ("you") for +instructions. Where a command requires sudo, the prompt shows it explicitly. + +```markdown +# Vestige Postgres Backend -- Operator Runbook + +This runbook covers deploying, operating, monitoring, and recovering a +Vestige installation that uses the Postgres backend. It is written for +operators handling a built `vestige-mcp` binary and a `vestige.toml`. + +For local development setup, see +`docs/plans/local-dev-postgres-setup.md`. For the architectural rationale, +see `docs/adr/0001-pluggable-storage-and-network-access.md` and +`docs/adr/0002-phase-2-execution.md`. For the deliverable-level plan, see +`docs/plans/0002-phase-2-postgres-backend.md`. + +--- + +## 1. Prerequisites + +Before Vestige can connect: + +- PostgreSQL server, version 16 or newer. Arch ships 18.x; Debian stable + ships 16.x; both work. +- `pgvector` extension, version 0.5 or newer. Distro packages: + `pgvector` on Arch, `postgresql-16-pgvector` on Debian/Ubuntu. +- `pgcrypto` extension, shipped with the PostgreSQL contrib package + (`postgresql-contrib` on Debian, included in the base `postgresql` + package on Arch). Vestige uses `gen_random_uuid()` from pgcrypto for + primary keys. +- Disk space: budget roughly 4x the size of your `knowledge_nodes.embedding` + column for the HNSW index. With 768-dim float32 vectors at 100k + memories, that is about 1.2 GB for the embeddings plus 4-5 GB for the + HNSW index. Plan accordingly. +- OS user: the `postgres` system user (or whatever user owns + `/var/lib/postgres/data`) must have read/write on the data directory. + Vestige itself does not need filesystem access to Postgres; it talks + TCP only. +- Network: Vestige and Postgres can be on the same host (loopback) or + different hosts. If different hosts, allow the Vestige host's IP in + `pg_hba.conf` and on any firewall. + +--- + +## 2. Initial setup + +These steps run once per Postgres cluster. + +### 2.1 Install extensions + +As the `postgres` superuser: + +```sh +sudo -u postgres psql -d vestige <<'SQL' +CREATE EXTENSION IF NOT EXISTS vector; +CREATE EXTENSION IF NOT EXISTS pgcrypto; +SQL +``` + +Verify: + +```sh +sudo -u postgres psql -d vestige -c \ + "SELECT extname, extversion FROM pg_extension WHERE extname IN ('vector','pgcrypto');" +``` + +You should see two rows. If `vector` is missing, the pgvector package was +not installed for the right PostgreSQL major version; reinstall it. + +### 2.2 Create the role and database + +The `vestige` role owns its own database; it does NOT need superuser. +Extensions must be installed by `postgres`, not by `vestige`. + +```sh +sudo -u postgres psql -v ON_ERROR_STOP=1 <<'SQL' +CREATE ROLE vestige WITH LOGIN CREATEDB PASSWORD 'CHANGE_ME'; +CREATE DATABASE vestige OWNER vestige ENCODING 'UTF8'; +GRANT ALL PRIVILEGES ON DATABASE vestige TO vestige; +SQL + +sudo -u postgres psql -d vestige -v ON_ERROR_STOP=1 <<'SQL' +GRANT ALL ON SCHEMA public TO vestige; +ALTER SCHEMA public OWNER TO vestige; +ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON TABLES TO vestige; +ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON SEQUENCES TO vestige; +ALTER DEFAULT PRIVILEGES IN SCHEMA public GRANT ALL ON FUNCTIONS TO vestige; +SQL +``` + +Replace `CHANGE_ME` with a strong password and store it where Vestige can +read it (typically `~/.vestige_pg_pw`, mode 600, owned by the user running +`vestige-mcp`). + +### 2.3 Minimal `vestige.toml` + +```toml +[storage] +backend = "postgres" + +[storage.postgres] +url = "postgresql://vestige:CHANGE_ME@127.0.0.1:5432/vestige" +max_connections = 10 +``` + +The `url` field accepts a `${VAR}` placeholder; in practice operators +either inline the password or export `DATABASE_URL` and reference +`url = "${DATABASE_URL}"`. See `docs/CONFIGURATION.md` for the full +schema once Phase 3 lands. + +--- + +## 3. First connect + +When `vestige-mcp` starts against an empty `vestige` database, it: + +1. Builds a `PgPool` of `max_connections` (default 10) connections. +2. Runs every migration in `crates/vestige-core/migrations/postgres/` + in order. The bundled migrations are `0001_init` (tables, non-vector + indexes) and `0002_hnsw` (HNSW index on `knowledge_nodes.embedding`). +3. Calls `register_model` once it knows the active embedder's dimension. + This issues `ALTER TABLE knowledge_nodes ALTER COLUMN embedding TYPE + vector($N)` and inserts a row into `embedding_model`. +4. Begins accepting MCP requests. + +To verify after the first start: + +```sh +sudo -u postgres psql -d vestige <<'SQL' +-- All expected tables present. +\dt +-- embedding_model has exactly one row. +SELECT name, dimension, hash FROM embedding_model; +-- The HNSW index exists. +SELECT indexname FROM pg_indexes + WHERE tablename = 'knowledge_nodes' AND indexname LIKE '%hnsw%'; +SQL +``` + +Expected: `knowledge_nodes`, `scheduling`, `edges`, `domains`, `review_events`, +`embedding_model`, `users`, `groups`, `group_memberships`; one row in +`embedding_model`; one `idx_knowledge_nodes_embedding_hnsw` index. + +If a migration fails mid-way, the partial state lands in +`_sqlx_migrations`. See section 9 for recovery. + +--- + +## 4. Connection pool tuning + +Defaults: + +- Vestige client pool: `max_connections = 10` per `vestige-mcp` instance. +- Postgres server: `max_connections = 100` (default). + +Math: one MCP client with the default pool uses up to 10 server slots. +Five concurrent MCP clients use up to 50 slots. The remaining 50 cover +`psql` sessions, background workers, and headroom for replication or +backup processes. + +When to raise: + +- More than three MCP clients connecting to one Postgres instance. +- Long-running queries (above 500ms p99) showing pool wait time in + Vestige logs (look for `pool acquire timed out` warnings). +- A noticeable number of concurrent dream/consolidation runs. + +How to raise: + +```toml +[storage.postgres] +max_connections = 20 # client side, per vestige-mcp instance +``` + +And on the Postgres server, edit `postgresql.conf`: + +```conf +max_connections = 200 +shared_buffers = 2GB # roughly 25 percent of RAM, never above 8GB +``` + +Then restart Postgres (`sudo systemctl restart postgresql`). Vestige +clients pick up their own `max_connections` change on next restart. + +Do not raise pool sizes blindly. Past about 4x the CPU core count, +Postgres throughput drops; a small connection pooler (PgBouncer in +transaction mode) is the right answer above ~200 client connections, +but Vestige's expected scale rarely needs that. + +--- + +## 5. Backup discipline + +### 5.1 Which tables matter + +| Table | Backup priority | Regenerable? | +|-------|-----------------|--------------| +| `knowledge_nodes` | Critical | No | +| `scheduling` | Critical | No (FSRS state) | +| `embedding_model` | Critical | No (one row, but stamps the column type) | +| `users`, `groups`, `group_memberships` | Critical | No (Phase 3 will populate) | +| `review_events` | Important | Replayable by clients but tedious | +| `edges` | Optional | Yes (recomputed by spreading activation) | +| `domains` | Optional | Yes (Phase 4 recomputes by clustering) | + +For a typical single-operator install, dumping the whole database is +fastest and simplest. Skip the optional tables only if dump size becomes +a bandwidth problem. + +### 5.2 Full logical backup + +```sh +pg_dump --host=127.0.0.1 --username=vestige --format=custom \ + --file=vestige-$(date -u +%Y%m%dT%H%M%SZ).dump \ + vestige +``` + +The custom format compresses by default and works with parallel restore. +File size for 10k memories: roughly 80 MB. + +Frequency recommendations: + +- Daily for any installation with active ingest. +- Before every `vestige migrate reembed` run (see section 6). +- Before every Postgres major-version upgrade. +- Retain at least 7 daily, 4 weekly, 3 monthly dumps. Compress with + `--format=custom` (already gzipped) and keep them on different + storage from the database itself. + +### 5.3 Restore + +To a fresh database: + +```sh +sudo -u postgres createdb -O vestige vestige_restore +pg_restore --host=127.0.0.1 --username=vestige --dbname=vestige_restore \ + --jobs=4 vestige-20260301T030000Z.dump +``` + +To replace the live database (destructive; only after taking a fresh +dump): + +```sh +sudo systemctl stop vestige-mcp # or however the service is run +sudo -u postgres dropdb vestige +sudo -u postgres createdb -O vestige vestige +pg_restore --host=127.0.0.1 --username=vestige --dbname=vestige \ + --jobs=4 vestige-20260301T030000Z.dump +sudo systemctl start vestige-mcp +``` + +### 5.4 Restore drill + +Run a restore-to-throwaway-database every month and run `vestige search` +or a manual `psql` count against it. A backup you have not restored is a +backup you do not have. + +```sh +sudo -u postgres createdb -O vestige vestige_restore_drill +pg_restore --host=127.0.0.1 --username=vestige --dbname=vestige_restore_drill \ + --jobs=4 vestige-latest.dump +PGPASSWORD="$(cat ~/.vestige_pg_pw)" psql -h 127.0.0.1 -U vestige \ + -d vestige_restore_drill \ + -c 'SELECT count(*) FROM knowledge_nodes;' +sudo -u postgres dropdb vestige_restore_drill +``` + +--- + +## 6. Migration between embeddings + +Use `vestige migrate reembed` when: + +- Upgrading to a new embedding model that produces a different dimension + (for example, swapping from `nomic-embed-text-v1.5` 768D to a 1024D + model). +- Switching providers and the model hash differs even at the same + dimension. + +What it does: + +1. Reads every row from `knowledge_nodes`, re-encodes the `content` column + through the new embedder, and writes the new vector back. +2. Drops the HNSW index before the re-encode loop (this is the default; + `--concurrent-index` keeps it during the run at the cost of speed). +3. Updates the `embedding_model` row with the new name, dimension, and + hash. +4. Rebuilds the HNSW index with the new vectors. + +### 6.1 Before starting + +- Take a fresh backup (section 5.2). The tool refuses to start without a + `--yes` flag if it detects no recent backup; ignore at your peril. +- Stop ingest. Vestige's MCP server can stay running for read-only + access, but pause any client that calls `smart_ingest` or + `update_scheduling`. +- Have the new embedder model available locally. The CLI loads it + before the first row is touched; if loading fails, no data is changed. + +### 6.2 Running + +```sh +vestige migrate reembed --model= --yes +``` + +Add `--concurrent-index` if you cannot accept the brief window during +HNSW rebuild where queries do not use the index (sequential scan +fallback works but is slow). + +The tool prints a progress bar via `indicatif`. Expected throughput: +roughly 200 memories per second per CPU core for a 768D ONNX model. +10,000 memories on an 8-core box: about 6 seconds, plus HNSW rebuild +(another 30-90 seconds at that scale). + +### 6.3 Verifying completion + +```sh +sudo -u postgres psql -d vestige <<'SQL' +-- Registry reflects the new model. +SELECT name, dimension, hash FROM embedding_model; +-- HNSW index is present and not partial. +SELECT indexname, indexdef + FROM pg_indexes + WHERE tablename = 'knowledge_nodes' AND indexname LIKE '%hnsw%'; +-- All rows have a non-null embedding of the new dimension. +SELECT count(*) FILTER (WHERE embedding IS NULL) AS missing, + count(*) AS total + FROM knowledge_nodes; +SQL +``` + +Expected: registry shows the new model name and dimension, one HNSW +index, zero missing embeddings. + +### 6.4 Recovering from an interrupted run + +`vestige migrate reembed` is restartable. On interruption: + +- The `embedding_model` row may or may not have been updated. Check it + manually and roll forward by re-running with `--yes --resume` (the + tool detects the inconsistency and finishes the rows that still hold + old embeddings). +- The HNSW index may be missing. Re-running the command rebuilds it as + its last step. +- If the system is in a state the tool refuses to reason about, restore + from the backup taken in 6.1. + +--- + +## 7. Re-clustering domains + +Domain clustering is owned by Phase 4 +(`docs/plans/0004-phase-4-emergent-domain-classification.md`). Until +Phase 4 ships, the `domains` table is reserved schema and is populated +only by tests. Operators must not invoke any domain re-clustering +workflow manually; there is no supported one in Phase 2. + +When Phase 4 lands, this section is replaced with the real procedure. + +--- + +## 8. Monitoring + +### 8.1 Quick health check + +```sh +PGPASSWORD="$(cat ~/.vestige_pg_pw)" psql -h 127.0.0.1 -U vestige -d vestige <<'SQL' +SELECT count(*) AS memory_count FROM knowledge_nodes; +SELECT name, dimension FROM embedding_model; +SELECT pg_size_pretty(pg_database_size('vestige')) AS db_size; +SQL +``` + +### 8.2 In-flight queries + +```sql +SELECT pid, now() - query_start AS runtime, state, query + FROM pg_stat_activity + WHERE datname = 'vestige' AND state <> 'idle' + ORDER BY runtime DESC NULLS LAST; +``` + +Anything over 5 seconds with `state = 'active'` deserves a look. HNSW +search queries should land well under 100ms on properly-sized hardware. + +### 8.3 Query pattern analysis + +If `pg_stat_statements` is loaded (`shared_preload_libraries = +'pg_stat_statements'` in `postgresql.conf`): + +```sql +SELECT calls, mean_exec_time, query + FROM pg_stat_statements + WHERE query ILIKE '%knowledge_nodes%' + ORDER BY mean_exec_time DESC + LIMIT 20; +``` + +Look for hybrid-search queries that have drifted above 100ms p50. The +usual culprit is a missing or half-built HNSW index. + +### 8.4 Index health + +```sql +SELECT indexname, pg_size_pretty(pg_relation_size(indexrelid)) AS size, + idx_scan, idx_tup_read + FROM pg_indexes + JOIN pg_stat_user_indexes USING (indexrelid) + WHERE schemaname = 'public' AND relname = 'knowledge_nodes'; +``` + +A HNSW index with `idx_scan = 0` after several hours of traffic usually +means the planner is preferring sequential scan -- either the table is +too small to bother with the index (fine) or the index is corrupt and +needs rebuilding (`REINDEX INDEX idx_knowledge_nodes_embedding_hnsw;`). + +### 8.5 Spotting half-built HNSW + +After a failed migration or a crashed `reembed`: + +```sql +SELECT indexname, indisvalid, indisready + FROM pg_indexes + JOIN pg_index ON indexrelid = (schemaname || '.' || indexname)::regclass + WHERE tablename = 'knowledge_nodes'; +``` + +Any row with `indisvalid = false` is broken. Drop and recreate: + +```sql +DROP INDEX IF EXISTS idx_knowledge_nodes_embedding_hnsw; +CREATE INDEX idx_knowledge_nodes_embedding_hnsw + ON knowledge_nodes USING hnsw (embedding vector_cosine_ops); +``` + +--- + +## 9. Troubleshooting + +| Symptom | Likely cause | Fix | +|---------|--------------|-----| +| `ERROR: extension "vector" is not available` on start | pgvector not installed for this Postgres major version | Install the distro package matching `pg_config --version`, then `CREATE EXTENSION vector;` as superuser | +| `pool timed out while waiting for an open connection` in Vestige logs | Pool too small or stuck queries holding connections | Raise `max_connections` in `vestige.toml`; investigate `pg_stat_activity` for queries above 5s | +| `vector dimensions do not match` on insert | `embedding_model` was stamped at one dimension and a different embedder is now running | Re-run `vestige migrate reembed --model=` or fix the embedder configuration | +| Hybrid search returns the same row twice | Stale `.sqlx/` query cache from before D5 landed | Run `cargo sqlx prepare` in `crates/vestige-core/`, rebuild the binary | +| `text search configuration "english" does not exist` | Postgres locale build does not include the english dictionary (rare on Alpine) | Install the language-pack or override the FTS language in `vestige.toml` (see `[storage.postgres.fts]` once Phase 2 D5 lands) | +| `relation "_sqlx_migrations" exists, but migration X is in "applied" with no checksum` | Previous run died between `BEGIN` and `COMMIT` | Stop Vestige, restore from backup, restart | +| HNSW index very large compared to data | `m` and `ef_construction` defaults too high for the corpus | Acceptable for now; tuning lands as part of Phase 4 | +| `permission denied for schema public` on a new install | `vestige` role does not own `public` | Re-run the grants block in section 2.2 as `postgres` | + +If a problem is not in this table, capture: PostgreSQL log +(`/var/log/postgres/`, journalctl `-u postgresql`), Vestige log +(`RUST_LOG=debug,sqlx=info` for a fresh run), the migration state +(`SELECT * FROM _sqlx_migrations ORDER BY version;`), and file a bug. + +--- + +## 10. Rollback caveats + +Every migration in `crates/vestige-core/migrations/postgres/` has a +matching `*.down.sql`. `sqlx migrate revert` walks them in reverse order. + +This is not the same as risk-free. The `0002_hnsw.down.sql` drops the +HNSW index (rebuildable, expensive). The `0001_init.down.sql` drops +every table -- including `knowledge_nodes`, including data. Down migrations +exist for development, not for casual production use. + +Before applying any new migration: + +1. Take a backup (section 5.2). +2. Run the migration on a restored copy first if you can afford the time. +3. Read the new migration's `*.up.sql` and `*.down.sql` to understand + what changes. + +To revert one migration manually: + +```sh +sqlx migrate revert \ + --database-url "postgresql://vestige:...@127.0.0.1:5432/vestige" \ + --source crates/vestige-core/migrations/postgres +``` + +Note that Vestige's binary does not run `sqlx migrate revert` +automatically. Reverts are always an explicit operator decision. + +If a revert fails partway through, treat the database as inconsistent: +restore from the backup taken in step 1. +``` + +--- + +## Cross-references + +- `docs/adr/0001-pluggable-storage-and-network-access.md` -- ADR that + established the pluggable backend. +- `docs/adr/0002-phase-2-execution.md` -- ADR settling Phase 2 execution + decisions; section "Architecture Overview" lists every table the + runbook references. +- `docs/plans/0002-phase-2-postgres-backend.md` -- master plan; D16 + (deliverables list) and the Open Implementation Questions section + (especially Q4 HNSW rebuild and Q5 pool sizing) inform the runbook's + recommendations. +- `docs/plans/local-dev-postgres-setup.md` -- developer-facing recipe + for a one-machine Arch / CachyOS dev cluster. The runbook links to it + as the "for development, see" pointer. +- `docs/CONFIGURATION.md` -- existing config doc; section 4 of the + runbook ("Connection pool tuning") cross-references it for the + authoritative `vestige.toml` schema. + +--- + +## Verification + +A reviewer is given: + +- A fresh Linux VM (Debian 12 or Arch current; both must work) with + network access and no Postgres installed. +- A built `vestige-mcp` binary for that platform. +- The runbook (`docs/runbook/postgres.md`). + +The reviewer follows the runbook top to bottom and reaches a state in +which Vestige answers MCP requests against the Postgres backend. +Checkpoints, in order: + +1. After section 1 (Prerequisites): `pg_config --version` returns 16 or + newer; `pkg-config --modversion libpq` resolves; the `pgvector` + distro package is installed. +2. After section 2.1 (Extensions): two rows in + `SELECT extname FROM pg_extension WHERE extname IN ('vector', 'pgcrypto');`. +3. After section 2.2 (Role + DB): `psql -U vestige -h 127.0.0.1 -d vestige -c '\conninfo'` + succeeds. +4. After section 2.3 (Config): `vestige.toml` parses (test by + `vestige config print` once that subcommand lands, otherwise + `vestige-mcp --check-config`). +5. After section 3 (First connect): the eight expected tables are + present; `embedding_model` has exactly one row; the HNSW index + exists; `vestige-mcp` log shows "Postgres backend ready". +6. After section 5.2 (Backup): the dump file exists and `pg_restore -l` + on it lists the expected tables. +7. After section 5.4 (Restore drill): the drill database holds the same + row count as the source. + +If any checkpoint fails, the runbook section that produced the failure +is the one that needs revision. Capture the exact command, exit code, +and log line; revise the runbook in a follow-up PR. + +A second reviewer reads the runbook without executing it and checks for: + +- ASCII only; no em dashes, no curly quotes, no Unicode arrows, no + ellipses, no bullets (`*`/`-` ASCII only). +- Every section number from 1 to 10 present and in order. +- Every cross-reference resolves to an existing file or to a Phase + number explicitly marked as "future". +- No code block longer than 30 lines; if longer, it should be split or + referenced from another file. + +--- + +## Acceptance criteria + +- [ ] `docs/runbook/` directory exists. +- [ ] `docs/runbook/postgres.md` exists and matches the inlined body + above byte-for-byte after stripping the outer code fence used in + this sub-plan to embed it. +- [ ] All ten sections from the "Runbook structure" outline are present + under their stated headings. +- [ ] No file other than `docs/runbook/postgres.md` is created or + modified by executing this sub-plan. +- [ ] ASCII only: no em dashes, no curly quotes, no Unicode arrows, + no ellipses, no Unicode bullets (`grep -P '[^\x00-\x7F]' + docs/runbook/postgres.md` returns no matches). +- [ ] Every cross-reference in the runbook points at a file that exists + in the repository at the time of merge, OR is explicitly framed + as "future Phase N" with a pointer to the relevant plan document. +- [ ] Every command block is copy-pastable: no `` syntax + that does not also have an inline note describing what to + substitute. +- [ ] A second pair of eyes confirms the verification checkpoints in the + preceding section are reproducible. +- [ ] The runbook is no longer than the inlined body in this sub-plan; + operators reach the end without losing patience. From 21f0b29baeab80e7513075c9e274e069419300d3 Mon Sep 17 00:00:00 2001 From: Jan De Landtsheer Date: Wed, 27 May 2026 15:08:35 +0200 Subject: [PATCH 08/23] docs: rewrite local-dev-postgres-setup for container approach; bump pg16 -> pg18 Land the Postgres dev cluster recipe Jan provisioned on delandtj-home (rootless podman + pgvector/pgvector:pg18, PG 18.4, pgvector 0.8.2) and align all live ADR 0002 / Phase 2 sub-plan references from pg16 to pg18. - docs/plans/local-dev-postgres-setup.md -- rewritten end-to-end: podman container vestige-pg with --restart=always, named volume vestige-pgdata, PGDATA=/var/lib/postgresql/data/pgdata, port mapping 127.0.0.1:5432:5432, two-password split (superuser + app role), pgvector preinstalled, CREATE EXTENSION vector handled at setup, day-to-day commands, password rotation, dev-grade backup/restore, teardown, boot-persistence notes for rootless podman. Old native Arch install recipe moved to Out-of-scope (covered by image now). - docs/adr/0002-phase-2-execution.md -- the open-thread mention of pgvector/pgvector:pg16 in the Follow-ups section now reads pg18. - docs/plans/0002c-migrations.md -- container example in the local dev section updated to pg18. - docs/plans/0002d-store-impl-bodies.md -- testcontainers GenericImage tag pg16 -> pg18; prose reference updated. - docs/plans/0002h-testing-and-benches.md -- harness pg18 across testcontainers Postgres builder, image-caching prose, CI workflow example. The archival master plan (docs/plans/0002-phase-2-postgres-backend.md) keeps its original pg16 references intentionally; the supersession notice already points readers to the live sub-plans. --- docs/adr/0002-phase-2-execution.md | 2 +- docs/plans/0002c-migrations.md | 2 +- docs/plans/0002d-store-impl-bodies.md | 4 +- docs/plans/0002h-testing-and-benches.md | 14 +- docs/plans/local-dev-postgres-setup.md | 248 ++++++++++++++++++------ 5 files changed, 198 insertions(+), 72 deletions(-) diff --git a/docs/adr/0002-phase-2-execution.md b/docs/adr/0002-phase-2-execution.md index 6b6949f..5d590b4 100644 --- a/docs/adr/0002-phase-2-execution.md +++ b/docs/adr/0002-phase-2-execution.md @@ -504,7 +504,7 @@ own migrations. - Validate local Postgres dev cluster before PR C work begins. Recipe at `docs/plans/local-dev-postgres-setup.md` is correct but needs to be applied on this machine (delandtj-home): cluster is not initdb'd, pgvector is not - installed. Containerized `pgvector/pgvector:pg16` is a viable alternative + installed. Containerized `pgvector/pgvector:pg18` is a viable alternative if pgvector packaging is friction. See open discussion thread. ### Phase 4 sketch: `sharing_rules` and the precedence chain diff --git a/docs/plans/0002c-migrations.md b/docs/plans/0002c-migrations.md index ef8e35c..78b6ac6 100644 --- a/docs/plans/0002c-migrations.md +++ b/docs/plans/0002c-migrations.md @@ -843,7 +843,7 @@ podman run --rm -d --name vestige-pg \ -e POSTGRES_USER=vestige \ -e POSTGRES_DB=vestige \ -p 5432:5432 \ - docker.io/pgvector/pgvector:pg16 + docker.io/pgvector/pgvector:pg18 export DATABASE_URL="postgresql://vestige:devpw@127.0.0.1:5432/vestige" ``` diff --git a/docs/plans/0002d-store-impl-bodies.md b/docs/plans/0002d-store-impl-bodies.md index ad1d9b7..adfd8aa 100644 --- a/docs/plans/0002d-store-impl-bodies.md +++ b/docs/plans/0002d-store-impl-bodies.md @@ -1612,7 +1612,7 @@ use vestige_core::storage::postgres::PgMemoryStore; #[tokio::test] async fn round_trip_crud_search_scheduling_edges() { let docker = clients::Cli::default(); - let image = GenericImage::new("pgvector/pgvector", "pg16") + let image = GenericImage::new("pgvector/pgvector", "pg18") .with_env_var("POSTGRES_PASSWORD", "test") .with_env_var("POSTGRES_DB", "vestige_test") .with_exposed_port(5432); @@ -1759,7 +1759,7 @@ This sub-plan is complete when ALL of the following hold: and the `Visibility` enum is exported alongside it. The SQLite backend reads and writes the same four fields. 8. The `tests/postgres_round_trip.rs` integration test passes against - a `pgvector/pgvector:pg16` container (insert / get / update / delete + a `pgvector/pgvector:pg18` container (insert / get / update / delete / fts_search / vector_search / get_scheduling / update_scheduling / add_edge / get_edges / remove_edge / get_neighbors / cascade delete). diff --git a/docs/plans/0002h-testing-and-benches.md b/docs/plans/0002h-testing-and-benches.md index d6bcebc..3fc2e1e 100644 --- a/docs/plans/0002h-testing-and-benches.md +++ b/docs/plans/0002h-testing-and-benches.md @@ -166,12 +166,12 @@ use vestige_core::storage::postgres::PgMemoryStore; pub async fn fresh_pg_store( embedder: Arc, ) -> Result<(PgMemoryStore, ContainerAsync)> { - // pgvector/pgvector:pg16 is the official pgvector image built on the - // postgres:16 base. testcontainers-modules::postgres::Postgres targets + // pgvector/pgvector:pg18 is the official pgvector image built on the + // postgres:18 base. testcontainers-modules::postgres::Postgres targets // the upstream postgres image by default; we override name + tag. let container = Postgres::default() .with_name("pgvector/pgvector") - .with_tag("pg16") + .with_tag("pg18") .start() .await?; @@ -867,7 +867,7 @@ Requirements: the `docker_available()` check in `common/mod.rs`. The test output includes a `docker unavailable; skip` line per test so the developer knows the tests were not silently dropped. -- The pgvector image (`pgvector/pgvector:pg16`) is pulled on first run; +- The pgvector image (`pgvector/pgvector:pg18`) is pulled on first run; ~200 MB. A pre-pulled image keeps the per-run overhead at the cold-start container boot (~2-5 seconds). @@ -920,7 +920,7 @@ async fn build_bench(rows: usize) -> Bench { let embedder = TestEmbedder::new_768(); let container = Postgres::default() .with_name("pgvector/pgvector") - .with_tag("pg16") + .with_tag("pg18") .start() .await .unwrap(); @@ -1092,7 +1092,7 @@ Notes: - The Postgres feature tests should run in a separate CI matrix entry to isolate failures and skip them entirely on platforms (Windows runners if any) where the pgvector image is not available. -- Cache the `pgvector/pgvector:pg16` image between runs. The +- Cache the `pgvector/pgvector:pg18` image between runs. The `docker/setup-buildx-action` cache or a simple `docker pull` step before the test step keeps cold-start under the existing CI time budget. - Skip CI: contributors without Docker can still merge changes that do @@ -1113,7 +1113,7 @@ jobs: # no `postgres` service block needed; testcontainers manages its own steps: - uses: actions/checkout@v4 - - run: docker pull pgvector/pgvector:pg16 + - run: docker pull pgvector/pgvector:pg18 - uses: dtolnay/rust-toolchain@stable - run: cargo test -p vestige-core --features postgres-backend --test '*' ``` diff --git a/docs/plans/local-dev-postgres-setup.md b/docs/plans/local-dev-postgres-setup.md index 6250a55..f863d48 100644 --- a/docs/plans/local-dev-postgres-setup.md +++ b/docs/plans/local-dev-postgres-setup.md @@ -1,27 +1,55 @@ -# Local Dev Postgres Setup (Arch / CachyOS) +# Local Dev Postgres Setup (container, hybrid approach) -**Status**: Applied on this machine on 2026-04-21 -**Related**: docs/plans/0002-phase-2-postgres-backend.md, docs/adr/0001-pluggable-storage-and-network-access.md +**Status**: Applied on this machine on 2026-05-27 (rootless podman, Postgres 18.4 + pgvector 0.8.2). +**Related**: docs/plans/0002-phase-2-postgres-backend.md, docs/adr/0002-phase-2-execution.md, docs/adr/0001-pluggable-storage-and-network-access.md -Purpose: capture the minimum, repeatable steps to stand up a Postgres 18 instance on a local Arch/CachyOS box for Phase 2 (`PgMemoryStore`) development, `sqlx prepare`, and manual migration testing. This is a single-operator dev recipe, not a production runbook. +Purpose: capture the minimum, repeatable steps to stand up a long-lived +Postgres 18 + pgvector instance on a local Linux dev box for Phase 2 +(`PgMemoryStore`) development, `sqlx prepare`, and manual migration +testing. This is a single-operator dev recipe, not a production runbook. + +ADR 0002 picked the **hybrid container** approach over a native install: +the `pgvector/pgvector:pg18` image ships pgvector pre-installed, matches +the image testcontainers will use in the Phase 2 test harness, and avoids +the AUR/build-from-source friction of native pgvector packaging on Arch. --- ## Current state on this machine -- Package: `postgresql` 18.3-2 (pacman). Pulls `postgresql-libs`, `libxslt`. -- Service: `postgresql.service`, enabled + active. -- Listens on: `127.0.0.1:5432` and `[::1]:5432` only (default `listen_addresses = 'localhost'`). -- Data dir: `/var/lib/postgres/data`, owner `postgres:postgres`. -- Auth (`pg_hba.conf`, Arch defaults): `peer` for local socket, `scram-sha-256` for host 127.0.0.1/::1. +- Runtime: rootless `podman` 5.8.2 (Arch). `docker` 29.5.1 also installed but unused. +- Image: `docker.io/pgvector/pgvector:pg18` (PostgreSQL 18.4, pgvector 0.8.2). +- Container: `vestige-pg`, `--restart=always`, port `127.0.0.1:5432:5432`. +- Volume: named podman volume `vestige-pgdata`, mounted at + `/var/lib/postgresql/data` inside the container; `PGDATA` points at + `/var/lib/postgresql/data/pgdata` so the volume mount is non-empty at + init time (Postgres refuses to initdb into a non-empty directory). +- Listens on: `127.0.0.1:5432` only (port mapping is bound to loopback). +- Auth: `scram-sha-256` (image default for both local socket and host). ### Database + role -- Database: `vestige`, UTF8, owner `vestige`. -- Role: `vestige` with `LOGIN CREATEDB` (no superuser, no replication, no cross-db). -- Schema `public` re-owned to `vestige`, plus default privileges so any future tables / sequences / functions in `public` are fully owned and granted to `vestige`. +- Database: `vestige`, UTF8, owner `vestige`, `LC_COLLATE=C.UTF-8`, `LC_CTYPE=C.UTF-8`. +- Role: `vestige` with `LOGIN CREATEDB` (no superuser, no replication). +- Schema `public` re-owned to `vestige` with full default privileges on + future tables / sequences / functions. +- Extension: `vector` (pgvector 0.8.2) installed in the `vestige` + database by the superuser at setup time. -Net effect: the `vestige` role can create, alter, drop, and grant freely inside the `vestige` database -- enough for `sqlx::migrate!`, ad-hoc schema work, and the full Phase 2 `MemoryStore` surface. It cannot create extensions (see Phase 2 followups below) and cannot touch other databases. +Net effect: the `vestige` role can create, alter, drop, and grant freely +inside the `vestige` database -- enough for `sqlx::migrate!`, ad-hoc +schema work, and the full Phase 2 `MemoryStore` surface. It cannot create +extensions; the superuser handled `CREATE EXTENSION vector` already. + +### Passwords + +Two passwords live in the dev user's home, mode 600: + +- `~/.vestige_pg_superpw` -- the `postgres` superuser password inside the + container. Used for one-shot admin tasks (creating roles, installing + extensions, password rotation). Day-to-day app traffic does NOT use it. +- `~/.vestige_pg_pw` -- the `vestige` role password. This is the one the + Phase 2 backend, `sqlx prepare`, and ad-hoc `psql` invocations use. ### Connection @@ -29,13 +57,8 @@ Net effect: the `vestige` role can create, alter, drop, and grant freely inside postgresql://vestige:@127.0.0.1:5432/vestige ``` -Password lives at `~/.vestige_pg_pw`, mode 600, owned by the dev user (no sudo needed to read it). Read with: - -```sh -cat ~/.vestige_pg_pw -``` - -Recommended dev shell export (keep this OUT of the repo; use `.env` + gitignore or a shell rc): +Recommended dev shell export (keep this OUT of the repo; use `.env` + +gitignore or a shell rc): ```sh export DATABASE_URL="postgresql://vestige:$(cat ~/.vestige_pg_pw)@127.0.0.1:5432/vestige" @@ -45,109 +68,212 @@ export DATABASE_URL="postgresql://vestige:$(cat ~/.vestige_pg_pw)@127.0.0.1:5432 ## Reproduce from scratch -On a fresh Arch / CachyOS box with passwordless sudo: +On a fresh Linux box with `podman` installed and `python3` available: ```sh -# 1. Install -sudo pacman -S --noconfirm postgresql +# 1. Pull the image +podman pull docker.io/pgvector/pgvector:pg18 -# 2. Initialize the cluster (UTF8, scram-sha-256 for host, peer for local) -sudo -iu postgres initdb \ - --locale=C.UTF-8 --encoding=UTF8 \ - -D /var/lib/postgres/data \ - --auth-host=scram-sha-256 --auth-local=peer +# 2. Create a persistent named volume +podman volume create vestige-pgdata -# 3. Start + enable -sudo systemctl enable --now postgresql +# 3. Generate the superuser password and stash it (mode 600) +SUPER_PW=$(python3 -c 'import secrets,string; a=string.ascii_letters+string.digits; print("".join(secrets.choice(a) for _ in range(32)))') +umask 077 +printf '%s' "$SUPER_PW" > ~/.vestige_pg_superpw +chmod 600 ~/.vestige_pg_superpw -# 4. Generate a password and stash it in the dev user's home (mode 600) +# 4. Start the container +podman run -d \ + --name vestige-pg \ + --restart=always \ + -p 127.0.0.1:5432:5432 \ + -e POSTGRES_PASSWORD="$SUPER_PW" \ + -e PGDATA=/var/lib/postgresql/data/pgdata \ + -v vestige-pgdata:/var/lib/postgresql/data \ + docker.io/pgvector/pgvector:pg18 + +unset SUPER_PW + +# 5. Wait for ready +until podman exec vestige-pg pg_isready -U postgres -h 127.0.0.1 >/dev/null 2>&1; do + sleep 1 +done + +# 6. Generate the vestige role password and stash it (mode 600) VESTIGE_PW=$(python3 -c 'import secrets,string; a=string.ascii_letters+string.digits; print("".join(secrets.choice(a) for _ in range(32)))') umask 077 printf '%s' "$VESTIGE_PW" > ~/.vestige_pg_pw chmod 600 ~/.vestige_pg_pw -# 5. Create role + database + grants -sudo -u postgres psql -v ON_ERROR_STOP=1 < '[3,2,1]'::vector AS l2_distance;" ``` --- -## Phase 2 followups (before PgMemoryStore works) +## Boot persistence (rootless podman) -The cluster above is bare Postgres. Phase 2 needs `pgvector`: +`--restart=always` keeps the container alive across podman daemon +restarts, but rootless podman containers do NOT auto-start on system +boot unless the dev user has lingering enabled: ```sh -# Install the extension package -sudo pacman -S --noconfirm pgvector - -# Enable it in the vestige database (must run as postgres; vestige is not superuser) -sudo -u postgres psql -d vestige -c 'CREATE EXTENSION IF NOT EXISTS vector;' +sudo loginctl enable-linger "$USER" ``` -Verify: +After that, the `podman-restart.service` user unit handles restart of +`--restart=always` containers when the user session starts at boot: ```sh -PGPASSWORD="$(cat ~/.vestige_pg_pw)" psql -h 127.0.0.1 -U vestige -d vestige \ - -c "SELECT extname, extversion FROM pg_extension WHERE extname = 'vector';" +systemctl --user enable --now podman-restart.service ``` -Notes: +Skip both if you prefer to start the cluster manually each session with +`podman start vestige-pg`. -- `pgvector` must be available on the server before `sqlx::migrate!` runs, or the Phase 2 migration that declares typed `Vector` columns will fail. -- Testcontainer-based Phase 2 integration tests use `pgvector/pgvector:pg16` and are independent of this local cluster. This local cluster is for `sqlx prepare`, `cargo run -- migrate --to postgres`, and manual poking. -- `sqlx prepare` needs `DATABASE_URL` pointed at this cluster with `vestige` migrations already applied. Run from `crates/vestige-core/`. +--- + +## Day-to-day operation + +```sh +# Status +podman ps --filter name=vestige-pg + +# Logs (follow) +podman logs -f vestige-pg + +# psql as the app role +PGPASSWORD="$(cat ~/.vestige_pg_pw)" psql -h 127.0.0.1 -U vestige -d vestige + +# psql as the superuser (for grants, extensions, role admin) +podman exec -it vestige-pg psql -U postgres + +# Stop / start +podman stop vestige-pg +podman start vestige-pg + +# Restart in place +podman restart vestige-pg +``` --- ## Password rotation ```sh +# Rotate the vestige role password NEW_PW=$(python3 -c 'import secrets,string; a=string.ascii_letters+string.digits; print("".join(secrets.choice(a) for _ in range(32)))') umask 077 printf '%s' "$NEW_PW" > ~/.vestige_pg_pw chmod 600 ~/.vestige_pg_pw -sudo -u postgres psql -v ON_ERROR_STOP=1 \ +podman exec -i vestige-pg psql -U postgres -v ON_ERROR_STOP=1 \ -c "ALTER ROLE vestige WITH PASSWORD '${NEW_PW}';" unset NEW_PW + +# Rotate the superuser password (less common) +NEW_SUPER=$(python3 -c 'import secrets,string; a=string.ascii_letters+string.digits; print("".join(secrets.choice(a) for _ in range(32)))') +umask 077 +printf '%s' "$NEW_SUPER" > ~/.vestige_pg_superpw +chmod 600 ~/.vestige_pg_superpw +podman exec -i vestige-pg psql -U postgres -v ON_ERROR_STOP=1 \ + -c "ALTER ROLE postgres WITH PASSWORD '${NEW_SUPER}';" +unset NEW_SUPER ``` Then re-export `DATABASE_URL` in any live shells. --- +## Backup and restore (dev-grade) + +`pg_dump` writes a plain-text SQL dump to host disk. For dev data this is +enough; production runbook lives in `0002i-runbook.md`. + +```sh +# Dump +PGPASSWORD="$(cat ~/.vestige_pg_pw)" pg_dump -h 127.0.0.1 -U vestige -d vestige \ + --format=plain --no-owner > vestige-$(date +%Y%m%d-%H%M%S).sql + +# Restore (drops + recreates) +podman exec -i vestige-pg psql -U postgres -v ON_ERROR_STOP=1 \ + -c 'DROP DATABASE IF EXISTS vestige;' \ + -c 'CREATE DATABASE vestige OWNER vestige ENCODING UTF8 TEMPLATE template0;' +PGPASSWORD="$(cat ~/.vestige_pg_pw)" psql -h 127.0.0.1 -U vestige -d vestige < vestige-DUMP.sql +``` + +The named volume `vestige-pgdata` persists outside the container; the +container can be `podman rm`'d and recreated without losing data, as +long as the volume stays in place. + +--- + ## Teardown Destroys the cluster and all data in it: ```sh -sudo systemctl disable --now postgresql -sudo pacman -Rns postgresql postgresql-libs -sudo rm -rf /var/lib/postgres -rm -f ~/.vestige_pg_pw +podman stop vestige-pg +podman rm vestige-pg +podman volume rm vestige-pgdata +podman rmi docker.io/pgvector/pgvector:pg18 +rm -f ~/.vestige_pg_pw ~/.vestige_pg_superpw ``` +`enable-linger` and the user systemd unit can be undone with +`sudo loginctl disable-linger "$USER"` and +`systemctl --user disable podman-restart.service` if you turned them on. + +--- + +## Notes for Phase 2 + +- `pgvector` is preinstalled in the image; the `CREATE EXTENSION vector` + in step 7 above makes it available inside the `vestige` DB. The + extension must be loaded BEFORE `sqlx::migrate!` runs the Phase 2 + migration that declares typed `Vector` columns, otherwise the + migration fails. +- Testcontainer-based Phase 2 integration tests use the same + `pgvector/pgvector:pg18` image and spin up fresh containers per run; + they are independent of this long-lived cluster. This cluster exists + for `sqlx prepare`, `cargo run -- migrate --to postgres`, and manual + poking. +- `sqlx prepare` needs `DATABASE_URL` pointed at this cluster with + `vestige` migrations already applied. Run from `crates/vestige-core/`. + --- ## Out of scope for this doc -- TLS, client-cert auth, non-localhost access. Phase 3 exposes the Vestige HTTP API over the network, not Postgres directly. -- Backups, PITR, WAL archiving. For dev data: `pg_dump -h 127.0.0.1 -U vestige vestige > vestige.sql`. -- Replication, PgBouncer, tuned `postgresql.conf`. Defaults are fine for Phase 2 development. -- Making this the canonical Vestige backend. By default Vestige still uses SQLite; this cluster exists so the `postgres-backend` feature can be built and tested locally. +- TLS, client-cert auth, non-localhost access. Phase 3 exposes the + Vestige HTTP API over the network, not Postgres directly. +- PITR, WAL archiving, replication, PgBouncer, tuned `postgresql.conf`. + Defaults are fine for Phase 2 development. +- Native (non-container) Postgres install. The prior version of this + doc covered native Arch packaging; superseded by ADR 0002's hybrid + decision. +- Making this the canonical Vestige backend. By default Vestige still + uses SQLite; this cluster exists so the `postgres-backend` feature + can be built and tested locally. From 14b061f124ef0acb9cff9bfe6d627726f82460dd Mon Sep 17 00:00:00 2001 From: Sam Valladares <143034159+samvallad33@users.noreply.github.com> Date: Wed, 27 May 2026 19:03:16 -0500 Subject: [PATCH 09/23] Release v2.1.23 Receipt Lock hardening Hardens Sanhedrin Receipt Lock for model-agnostic use, adds fail-open telemetry and receipt docs, fixes smart_ingest batch safety, wires opt-in CUDA Qwen3 device selection, and refreshes dashboard/release assets.\n\nFixes #54\nFixes #58\nFixes #60\nRefs #59 --- CHANGELOG.md | 44 +++ Cargo.lock | 120 +++++++- Cargo.toml | 2 +- README.md | 60 ++++ .../assets/{0.CN9L-NIY.css => 0.Bor8S3Zo.css} | 2 +- .../_app/immutable/assets/0.Bor8S3Zo.css.br | Bin 0 -> 10347 bytes .../{0.CN9L-NIY.css.gz => 0.Bor8S3Zo.css.gz} | Bin 12348 -> 12352 bytes .../_app/immutable/assets/0.CN9L-NIY.css.br | Bin 10353 -> 0 bytes .../_app/immutable/chunks/554JRhq6.js.br | Bin 632 -> 0 bytes .../_app/immutable/chunks/554JRhq6.js.gz | Bin 756 -> 0 bytes .../chunks/{554JRhq6.js => B7CfdQuM.js} | 2 +- .../_app/immutable/chunks/B7CfdQuM.js.br | Bin 0 -> 646 bytes .../_app/immutable/chunks/B7CfdQuM.js.gz | Bin 0 -> 774 bytes .../chunks/{D-gDZzN6.js => C2TQQEIa.js} | 2 +- .../_app/immutable/chunks/C2TQQEIa.js.br | Bin 0 -> 7642 bytes .../_app/immutable/chunks/C2TQQEIa.js.gz | Bin 0 -> 8430 bytes .../_app/immutable/chunks/D-gDZzN6.js.br | Bin 7644 -> 0 bytes .../_app/immutable/chunks/D-gDZzN6.js.gz | Bin 8427 -> 0 bytes .../chunks/{DGcYlAAw.js => D8UfWY0j.js} | 2 +- .../_app/immutable/chunks/D8UfWY0j.js.br | Bin 0 -> 2609 bytes .../_app/immutable/chunks/D8UfWY0j.js.gz | Bin 0 -> 2952 bytes .../_app/immutable/chunks/DGcYlAAw.js.br | Bin 2609 -> 0 bytes .../_app/immutable/chunks/DGcYlAAw.js.gz | Bin 2953 -> 0 bytes .../_app/immutable/entry/app.BIXcLtMB.js.br | Bin 3574 -> 0 bytes .../_app/immutable/entry/app.BIXcLtMB.js.gz | Bin 4071 -> 0 bytes .../{app.BIXcLtMB.js => app.Bv9rD2TH.js} | 4 +- .../_app/immutable/entry/app.Bv9rD2TH.js.br | Bin 0 -> 3598 bytes .../_app/immutable/entry/app.Bv9rD2TH.js.gz | Bin 0 -> 4072 bytes .../_app/immutable/entry/start.Bnkotnxp.js | 1 - .../_app/immutable/entry/start.Bnkotnxp.js.br | Bin 108 -> 0 bytes .../_app/immutable/entry/start.Bnkotnxp.js.gz | Bin 107 -> 0 bytes .../_app/immutable/entry/start.HXOjGRUF.js | 1 + .../_app/immutable/entry/start.HXOjGRUF.js.br | Bin 0 -> 111 bytes .../_app/immutable/entry/start.HXOjGRUF.js.gz | Bin 0 -> 108 bytes .../build/_app/immutable/nodes/0.BSxKGxRx.js | 86 ------ .../_app/immutable/nodes/0.BSxKGxRx.js.br | Bin 9644 -> 0 bytes .../_app/immutable/nodes/0.BSxKGxRx.js.gz | Bin 10974 -> 0 bytes .../build/_app/immutable/nodes/0.j0CpgSFp.js | 86 ++++++ .../_app/immutable/nodes/0.j0CpgSFp.js.br | Bin 0 -> 9928 bytes .../_app/immutable/nodes/0.j0CpgSFp.js.gz | Bin 0 -> 11290 bytes .../_app/immutable/nodes/1.CJFfVX1H.js.br | Bin 339 -> 0 bytes .../_app/immutable/nodes/1.CJFfVX1H.js.gz | Bin 383 -> 0 bytes .../nodes/{1.CJFfVX1H.js => 1.DEUqmURt.js} | 2 +- .../_app/immutable/nodes/1.DEUqmURt.js.br | Bin 0 -> 340 bytes .../_app/immutable/nodes/1.DEUqmURt.js.gz | Bin 0 -> 382 bytes .../nodes/{10.CjP_ylq3.js => 10.CACwABbv.js} | 2 +- .../_app/immutable/nodes/10.CACwABbv.js.br | Bin 0 -> 124073 bytes .../_app/immutable/nodes/10.CACwABbv.js.gz | Bin 0 -> 148779 bytes .../_app/immutable/nodes/10.CjP_ylq3.js.br | Bin 124081 -> 0 bytes .../_app/immutable/nodes/10.CjP_ylq3.js.gz | Bin 148779 -> 0 bytes .../nodes/{11.k15P8M2H.js => 11.B_W3XFQr.js} | 2 +- .../_app/immutable/nodes/11.B_W3XFQr.js.br | Bin 0 -> 4830 bytes .../_app/immutable/nodes/11.B_W3XFQr.js.gz | Bin 0 -> 5417 bytes .../_app/immutable/nodes/11.k15P8M2H.js.br | Bin 4827 -> 0 bytes .../_app/immutable/nodes/11.k15P8M2H.js.gz | Bin 5417 -> 0 bytes .../_app/immutable/nodes/12.BthmSU_R.js.br | Bin 2402 -> 0 bytes .../_app/immutable/nodes/12.BthmSU_R.js.gz | Bin 2710 -> 0 bytes .../nodes/{12.BthmSU_R.js => 12.DxkSrFsy.js} | 2 +- .../_app/immutable/nodes/12.DxkSrFsy.js.br | Bin 0 -> 2402 bytes .../_app/immutable/nodes/12.DxkSrFsy.js.gz | Bin 0 -> 2709 bytes .../_app/immutable/nodes/13.C0fh4g_5.js.br | Bin 5193 -> 0 bytes .../_app/immutable/nodes/13.C0fh4g_5.js.gz | Bin 5915 -> 0 bytes .../nodes/{13.C0fh4g_5.js => 13.CD5qzYsO.js} | 2 +- .../_app/immutable/nodes/13.CD5qzYsO.js.br | Bin 0 -> 5190 bytes .../_app/immutable/nodes/13.CD5qzYsO.js.gz | Bin 0 -> 5914 bytes .../nodes/{15.QNRJhGzj.js => 15.CyCv1LGV.js} | 2 +- .../_app/immutable/nodes/15.CyCv1LGV.js.br | Bin 0 -> 7453 bytes .../_app/immutable/nodes/15.CyCv1LGV.js.gz | Bin 0 -> 8511 bytes .../_app/immutable/nodes/15.QNRJhGzj.js.br | Bin 7442 -> 0 bytes .../_app/immutable/nodes/15.QNRJhGzj.js.gz | Bin 8512 -> 0 bytes .../nodes/{16.QhdtMP78.js => 16.Cth-SSqa.js} | 2 +- .../_app/immutable/nodes/16.Cth-SSqa.js.br | Bin 0 -> 5678 bytes .../_app/immutable/nodes/16.Cth-SSqa.js.gz | Bin 0 -> 6454 bytes .../_app/immutable/nodes/16.QhdtMP78.js.br | Bin 5681 -> 0 bytes .../_app/immutable/nodes/16.QhdtMP78.js.gz | Bin 6455 -> 0 bytes .../_app/immutable/nodes/17.DlzXJVdF.js.br | Bin 3392 -> 0 bytes .../_app/immutable/nodes/17.DlzXJVdF.js.gz | Bin 3853 -> 0 bytes .../nodes/{17.DlzXJVdF.js => 17.k6k7874Y.js} | 2 +- .../_app/immutable/nodes/17.k6k7874Y.js.br | Bin 0 -> 3389 bytes .../_app/immutable/nodes/17.k6k7874Y.js.gz | Bin 0 -> 3853 bytes .../_app/immutable/nodes/18.Bmu4OWRV.js.br | Bin 2023 -> 0 bytes .../_app/immutable/nodes/18.Bmu4OWRV.js.gz | Bin 2265 -> 0 bytes .../nodes/{18.Bmu4OWRV.js => 18.C60Wuzj2.js} | 2 +- .../_app/immutable/nodes/18.C60Wuzj2.js.br | Bin 0 -> 2022 bytes .../_app/immutable/nodes/18.C60Wuzj2.js.gz | Bin 0 -> 2264 bytes .../nodes/{19.Baocji37.js => 19.BIUSI5ln.js} | 2 +- .../_app/immutable/nodes/19.BIUSI5ln.js.br | Bin 0 -> 1557 bytes .../_app/immutable/nodes/19.BIUSI5ln.js.gz | Bin 0 -> 1753 bytes .../_app/immutable/nodes/19.Baocji37.js.br | Bin 1550 -> 0 bytes .../_app/immutable/nodes/19.Baocji37.js.gz | Bin 1755 -> 0 bytes .../_app/immutable/nodes/20.CJQuAMkU.js.br | Bin 5512 -> 0 bytes .../_app/immutable/nodes/20.CJQuAMkU.js.gz | Bin 6454 -> 0 bytes .../nodes/{20.CJQuAMkU.js => 20.DebghJca.js} | 2 +- .../_app/immutable/nodes/20.DebghJca.js.br | Bin 0 -> 5511 bytes .../_app/immutable/nodes/20.DebghJca.js.gz | Bin 0 -> 6455 bytes .../nodes/{3.mK8D6pz1.js => 3.Bu_uPddU.js} | 2 +- .../_app/immutable/nodes/3.Bu_uPddU.js.br | Bin 0 -> 164 bytes .../_app/immutable/nodes/3.Bu_uPddU.js.gz | Bin 0 -> 197 bytes .../_app/immutable/nodes/3.mK8D6pz1.js.br | Bin 165 -> 0 bytes .../_app/immutable/nodes/3.mK8D6pz1.js.gz | Bin 198 -> 0 bytes .../_app/immutable/nodes/4.DPhwyLUO.js.br | Bin 4437 -> 0 bytes .../_app/immutable/nodes/4.DPhwyLUO.js.gz | Bin 4976 -> 0 bytes .../nodes/{4.DPhwyLUO.js => 4.DYVet_v-.js} | 2 +- .../_app/immutable/nodes/4.DYVet_v-.js.br | Bin 0 -> 4439 bytes .../_app/immutable/nodes/4.DYVet_v-.js.gz | Bin 0 -> 4975 bytes .../nodes/{6.BD0AetaD.js => 6.54m-BxV_.js} | 2 +- .../_app/immutable/nodes/6.54m-BxV_.js.br | Bin 0 -> 5620 bytes .../_app/immutable/nodes/6.54m-BxV_.js.gz | Bin 0 -> 6334 bytes .../_app/immutable/nodes/6.BD0AetaD.js.br | Bin 5625 -> 0 bytes .../_app/immutable/nodes/6.BD0AetaD.js.gz | Bin 6335 -> 0 bytes .../_app/immutable/nodes/8.CokrlgDp.js.br | Bin 3017 -> 0 bytes .../_app/immutable/nodes/8.CokrlgDp.js.gz | Bin 3487 -> 0 bytes .../nodes/{8.CokrlgDp.js => 8.DGKslLJe.js} | 2 +- .../_app/immutable/nodes/8.DGKslLJe.js.br | Bin 0 -> 3012 bytes .../_app/immutable/nodes/8.DGKslLJe.js.gz | Bin 0 -> 3485 bytes apps/dashboard/build/_app/version.json | 2 +- apps/dashboard/build/_app/version.json.br | 2 +- apps/dashboard/build/_app/version.json.gz | Bin 40 -> 40 bytes apps/dashboard/build/index.html | 14 +- apps/dashboard/build/index.html.br | Bin 608 -> 609 bytes apps/dashboard/build/index.html.gz | Bin 791 -> 795 bytes apps/dashboard/package-lock.json | 4 +- apps/dashboard/package.json | 2 +- .../components/AmbientAwarenessStrip.svelte | 46 ++- apps/dashboard/src/lib/stores/api.ts | 4 +- apps/dashboard/src/lib/types/index.ts | 25 ++ crates/vestige-core/Cargo.toml | 13 +- crates/vestige-core/src/embeddings/local.rs | 6 + crates/vestige-core/src/storage/sqlite.rs | 61 +++- crates/vestige-mcp/Cargo.toml | 8 +- crates/vestige-mcp/src/bin/cli.rs | 45 ++- crates/vestige-mcp/src/bin/restore.rs | 27 +- crates/vestige-mcp/src/dashboard/handlers.rs | 236 +++++++++++++- crates/vestige-mcp/src/dashboard/mod.rs | 6 +- crates/vestige-mcp/src/main.rs | 17 +- crates/vestige-mcp/src/tools/smart_ingest.rs | 98 +++++- docs/COGNITIVE_SANDWICH.md | 22 +- docs/SANHEDRIN_RECEIPTS.md | 96 ++++++ hooks/sanhedrin-local.py | 161 ++++++++-- hooks/sanhedrin-presets.json | 103 +++++++ hooks/sanhedrin.sh | 44 ++- hooks/sanhedrin_core.py | 63 +++- package.json | 2 +- packages/vestige-init/package.json | 2 +- packages/vestige-mcp-npm/package.json | 2 +- packages/vestige-mcpb/README.md | 4 +- packages/vestige-mcpb/build.sh | 2 +- packages/vestige-mcpb/manifest.json | 2 +- scripts/check-sandwich-prereqs.sh | 18 +- scripts/install-sandwich.sh | 55 +++- server.json | 4 +- .../tests/cognitive/comparative_benchmarks.rs | 37 ++- tests/e2e/tests/cognitive/dreams_tests.rs | 4 +- tests/e2e/tests/extreme/adversarial_tests.rs | 8 +- tests/e2e/tests/extreme/chaos_tests.rs | 11 +- .../e2e/tests/extreme/proof_of_superiority.rs | 4 +- .../extreme/research_validation_tests.rs | 2 +- .../tests/journeys/consolidation_workflow.rs | 8 +- .../tests/journeys/ingest_recall_review.rs | 24 +- .../e2e/tests/journeys/intentions_workflow.rs | 11 +- tests/hooks/test_sanhedrin_claim_mode.py | 290 +++++++++++++++++- 161 files changed, 1775 insertions(+), 262 deletions(-) rename apps/dashboard/build/_app/immutable/assets/{0.CN9L-NIY.css => 0.Bor8S3Zo.css} (74%) create mode 100644 apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css.br rename apps/dashboard/build/_app/immutable/assets/{0.CN9L-NIY.css.gz => 0.Bor8S3Zo.css.gz} (70%) delete mode 100644 apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/554JRhq6.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/554JRhq6.js.gz rename apps/dashboard/build/_app/immutable/chunks/{554JRhq6.js => B7CfdQuM.js} (87%) create mode 100644 apps/dashboard/build/_app/immutable/chunks/B7CfdQuM.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/B7CfdQuM.js.gz rename apps/dashboard/build/_app/immutable/chunks/{D-gDZzN6.js => C2TQQEIa.js} (65%) create mode 100644 apps/dashboard/build/_app/immutable/chunks/C2TQQEIa.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/C2TQQEIa.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.gz rename apps/dashboard/build/_app/immutable/chunks/{DGcYlAAw.js => D8UfWY0j.js} (88%) create mode 100644 apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js.br create mode 100644 apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.br delete mode 100644 apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.br delete mode 100644 apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.gz rename apps/dashboard/build/_app/immutable/entry/{app.BIXcLtMB.js => app.Bv9rD2TH.js} (79%) create mode 100644 apps/dashboard/build/_app/immutable/entry/app.Bv9rD2TH.js.br create mode 100644 apps/dashboard/build/_app/immutable/entry/app.Bv9rD2TH.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js delete mode 100644 apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.br delete mode 100644 apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.gz create mode 100644 apps/dashboard/build/_app/immutable/entry/start.HXOjGRUF.js create mode 100644 apps/dashboard/build/_app/immutable/entry/start.HXOjGRUF.js.br create mode 100644 apps/dashboard/build/_app/immutable/entry/start.HXOjGRUF.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js delete mode 100644 apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.gz create mode 100644 apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js create mode 100644 apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.gz rename apps/dashboard/build/_app/immutable/nodes/{1.CJFfVX1H.js => 1.DEUqmURt.js} (80%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/1.DEUqmURt.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/1.DEUqmURt.js.gz rename apps/dashboard/build/_app/immutable/nodes/{10.CjP_ylq3.js => 10.CACwABbv.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CACwABbv.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CACwABbv.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/10.CjP_ylq3.js.gz rename apps/dashboard/build/_app/immutable/nodes/{11.k15P8M2H.js => 11.B_W3XFQr.js} (98%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/11.B_W3XFQr.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/11.B_W3XFQr.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/11.k15P8M2H.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/11.k15P8M2H.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/12.BthmSU_R.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/12.BthmSU_R.js.gz rename apps/dashboard/build/_app/immutable/nodes/{12.BthmSU_R.js => 12.DxkSrFsy.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/12.DxkSrFsy.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/12.DxkSrFsy.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/13.C0fh4g_5.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/13.C0fh4g_5.js.gz rename apps/dashboard/build/_app/immutable/nodes/{13.C0fh4g_5.js => 13.CD5qzYsO.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/13.CD5qzYsO.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/13.CD5qzYsO.js.gz rename apps/dashboard/build/_app/immutable/nodes/{15.QNRJhGzj.js => 15.CyCv1LGV.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/15.CyCv1LGV.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/15.CyCv1LGV.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/15.QNRJhGzj.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/15.QNRJhGzj.js.gz rename apps/dashboard/build/_app/immutable/nodes/{16.QhdtMP78.js => 16.Cth-SSqa.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/16.Cth-SSqa.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/16.Cth-SSqa.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/16.QhdtMP78.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/16.QhdtMP78.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/17.DlzXJVdF.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/17.DlzXJVdF.js.gz rename apps/dashboard/build/_app/immutable/nodes/{17.DlzXJVdF.js => 17.k6k7874Y.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/17.k6k7874Y.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/17.k6k7874Y.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/18.Bmu4OWRV.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/18.Bmu4OWRV.js.gz rename apps/dashboard/build/_app/immutable/nodes/{18.Bmu4OWRV.js => 18.C60Wuzj2.js} (98%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/18.C60Wuzj2.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/18.C60Wuzj2.js.gz rename apps/dashboard/build/_app/immutable/nodes/{19.Baocji37.js => 19.BIUSI5ln.js} (98%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/19.BIUSI5ln.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/19.BIUSI5ln.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/19.Baocji37.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/19.Baocji37.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/20.CJQuAMkU.js.gz rename apps/dashboard/build/_app/immutable/nodes/{20.CJQuAMkU.js => 20.DebghJca.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/20.DebghJca.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/20.DebghJca.js.gz rename apps/dashboard/build/_app/immutable/nodes/{3.mK8D6pz1.js => 3.Bu_uPddU.js} (56%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.gz rename apps/dashboard/build/_app/immutable/nodes/{4.DPhwyLUO.js => 4.DYVet_v-.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js.gz rename apps/dashboard/build/_app/immutable/nodes/{6.BD0AetaD.js => 6.54m-BxV_.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.gz delete mode 100644 apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.br delete mode 100644 apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.gz rename apps/dashboard/build/_app/immutable/nodes/{8.CokrlgDp.js => 8.DGKslLJe.js} (99%) create mode 100644 apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js.br create mode 100644 apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js.gz create mode 100644 docs/SANHEDRIN_RECEIPTS.md create mode 100644 hooks/sanhedrin-presets.json diff --git a/CHANGELOG.md b/CHANGELOG.md index f6825cb..490c01e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,50 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased] +## [2.1.23] - 2026-05-27 — "Receipt Lock Hardening" + +v2.1.23 hardens the Sanhedrin launch path so Receipt Lock is portable, +observable, and precise enough for broader use. + +### Added + +- **Model-agnostic Sanhedrin backend presets** for custom OpenAI-compatible + servers, small laptops, Ollama, MLX, vLLM, llama.cpp, hosted APIs, and + Anthropic via LiteLLM. Sanhedrin no longer guesses a large default verifier. +- **Fail-open telemetry** in `fail-open.jsonl`, plus a dashboard telemetry API + and 7-day ambient dashboard counters for vetoes, appeals, and fail-open runs. +- **Receipt schema documentation** covering receipt artifacts, appeals, command + ledgers, fail-open logs, compatibility rules, and staged-evidence trust + boundaries. +- **Opt-in CUDA feature flags** for Qwen3 embedding builds on NVIDIA hardware. + +### Changed + +- Receipt Lock strips code fences, inline code, blockquotes, quoted regions, and + scoped epistemic hedges before matching verification claims. +- Structured transcript tool-use receipts are the default evidence path; loose + JSON command scanning now requires `VESTIGE_SANHEDRIN_ALLOW_LOOSE_LEDGER=1`. +- Claim-mode sampling now prioritizes higher-severity claims instead of taking + the first eight source-order claims. +- Hosted Sanhedrin credentials now require `VESTIGE_SANHEDRIN_API_KEY` and are + only sent to the configured Sanhedrin endpoint, never to Vestige retrieval. +- `smart_ingest` batch mode now defaults to `batchMergePolicy: "force_create"` + so caller-separated items stay separate unless callers opt into smart merging. +- CUDA-enabled Qwen3 builds now try `Device::new_cuda(0)` before falling back to + Metal or CPU. + +### Fixed + +- Standalone dashboard mode now hydrates the cognitive engine for Dream and + Deep Reference instead of returning 503s. +- `--data-dir` now rejects existing non-directory paths with a clear error. +- `vestige-restore` now handles `--help` and `--version` instead of treating + them as backup file paths. +- Smart ingest merge/update responses now include `previousContent`, + `mergedFrom`, and `mergePreview` so callers can inspect mutated memories. +- Daily Sanhedrin telemetry now preserves NOTE and CAUTION buckets instead of + folding both into PASS. + ## [2.1.22] - 2026-05-25 — "Sanhedrin Receipts" v2.1.22 makes the optional Sanhedrin hook quieter and more accountable by diff --git a/Cargo.lock b/Cargo.lock index 70f3956..b9612d3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -392,8 +392,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6bd9895436c1ba5dc1037a19935d084b838db066ff4e15ef7dded020b7c12a4a" dependencies = [ "byteorder", + "candle-kernels", "candle-metal-kernels", "candle-ug", + "cudarc 0.19.7", "float8", "gemm 0.19.0", "half", @@ -413,6 +415,15 @@ dependencies = [ "zip", ] +[[package]] +name = "candle-kernels" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "742e2ac226b777134436e9e692f44e77c278b8a7abb1554dc10e44dc911b349f" +dependencies = [ + "cudaforge", +] + [[package]] name = "candle-metal-kernels" version = "0.10.2" @@ -453,6 +464,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ca0fc3167cbc99c8ec1be618cb620aa21dca95038f118c3579a79370e3dc5f77" dependencies = [ "ug", + "ug-cuda", "ug-metal", ] @@ -771,6 +783,46 @@ dependencies = [ "typenum", ] +[[package]] +name = "cudaforge" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f7a0d45b139b5beeeb1c34188717e12241c44a0120afb498815ce7f5373c691" +dependencies = [ + "anyhow", + "fs2", + "glob", + "num_cpus", + "rayon", + "serde", + "serde_json", + "sha2", + "thiserror 2.0.18", + "walkdir", + "which", +] + +[[package]] +name = "cudarc" +version = "0.17.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf99ab37ee7072d64d906aa2dada9a3422f1d975cdf8c8055a573bc84897ed8" +dependencies = [ + "half", + "libloading 0.8.9", +] + +[[package]] +name = "cudarc" +version = "0.19.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1cea5f10a99e025c1b44ae2354c2d8326b25ddbd0baf76bde8e55cfd4018a2cc" +dependencies = [ + "float8", + "half", + "libloading 0.9.0", +] + [[package]] name = "cxx" version = "1.0.194" @@ -1034,6 +1086,12 @@ dependencies = [ "syn", ] +[[package]] +name = "env_home" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c7f84e12ccf0a7ddc17a6c41c93326024c42920d7ee630d04950e6926645c0fe" + [[package]] name = "equator" version = "0.4.2" @@ -1254,6 +1312,16 @@ dependencies = [ "percent-encoding", ] +[[package]] +name = "fs2" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" +dependencies = [ + "libc", + "winapi", +] + [[package]] name = "fsevent-sys" version = "4.1.0" @@ -1632,6 +1700,12 @@ dependencies = [ "url", ] +[[package]] +name = "glob" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" + [[package]] name = "h2" version = "0.4.13" @@ -3752,6 +3826,17 @@ dependencies = [ "digest", ] +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures", + "digest", +] + [[package]] name = "sharded-slab" version = "0.1.7" @@ -4327,6 +4412,19 @@ dependencies = [ "yoke 0.7.5", ] +[[package]] +name = "ug-cuda" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f0a1fa748f26166778c33b8498255ebb7c6bffb472bcc0a72839e07ebb1d9b5" +dependencies = [ + "cudarc 0.17.8", + "half", + "serde", + "thiserror 1.0.69", + "ug", +] + [[package]] name = "ug-metal" version = "0.5.0" @@ -4531,7 +4629,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" [[package]] name = "vestige-core" -version = "2.1.22" +version = "2.1.23" dependencies = [ "candle-core", "chrono", @@ -4567,7 +4665,7 @@ dependencies = [ [[package]] name = "vestige-mcp" -version = "2.1.22" +version = "2.1.23" dependencies = [ "anyhow", "axum", @@ -4792,6 +4890,18 @@ version = "0.1.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88" +[[package]] +name = "which" +version = "7.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d643ce3fd3e5b54854602a080f34fb10ab75e0b813ee32d00ca2b44fa74762" +dependencies = [ + "either", + "env_home", + "rustix", + "winsafe", +] + [[package]] name = "winapi" version = "0.3.9" @@ -5058,6 +5168,12 @@ version = "0.53.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650" +[[package]] +name = "winsafe" +version = "0.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d135d17ab770252ad95e9a872d365cf3090e3be864a34ab46f48555993efc904" + [[package]] name = "wit-bindgen" version = "0.51.0" diff --git a/Cargo.toml b/Cargo.toml index 5cbe508..f120928 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,7 @@ exclude = [ ] [workspace.package] -version = "2.1.22" +version = "2.1.23" edition = "2024" license = "AGPL-3.0-only" repository = "https://github.com/samvallad33/vestige" diff --git a/README.md b/README.md index 3c18759..674eebb 100644 --- a/README.md +++ b/README.md @@ -20,6 +20,19 @@ Built on proven memory and retrieval ideas — FSRS-6 spaced repetition, predict --- +## What's New in v2.1.23 "Receipt Lock Hardening" + +v2.1.23 turns the Sanhedrin Receipt Lock launch into something more portable, +observable, and harder to spoof. + +- **Model-agnostic Sanhedrin presets.** Sanhedrin no longer guesses a large default verifier. Users choose any OpenAI-compatible endpoint/model, or start from custom, small laptop, Ollama, MLX, vLLM, llama.cpp, hosted API, or LiteLLM presets. +- **Sharper Receipt Lock.** Verification claims inside code fences, quotes, blockquotes, or explicitly hedged "let me verify" language no longer trigger false vetoes, while actual "tests passed" claims still require command receipts. +- **Safer command receipts.** Transcript command evidence now prefers structured tool-use receipts; loose JSON scanning is opt-in only. +- **Visible fail-open telemetry.** Timeouts, unavailable model endpoints, and malformed verdicts are logged locally and surfaced in the dashboard's 7-day Sanhedrin stats. +- **Durable evidence boundary.** Staged evidence remains useful context, but it cannot satisfy durable support or contradiction requirements by itself. +- **Safer batch writes.** `smart_ingest` batch mode now keeps caller-separated items separate by default and returns merge previews when an existing memory is mutated. +- **Opt-in NVIDIA acceleration path.** Qwen3 embedding builds expose CUDA/cuDNN feature flags for contributors and users with CUDA-capable hosts. + ## What's New in v2.1.22 "Sanhedrin Receipts" v2.1.22 makes the optional Sanhedrin hook accountable enough to trust in daily @@ -444,6 +457,53 @@ cargo build --release -p vestige-mcp --features qwen3-embeddings,metal VESTIGE_EMBEDDING_MODEL=qwen3-0.6b vestige consolidate ``` +### Building with CUDA support (NVIDIA hosts - Windows / Linux) + +The `cuda` feature routes Qwen3 embedding through NVIDIA GPUs via +`candle-core/cuda`. On a host with the CUDA toolkit installed and a supported +NVIDIA runtime, this drops Qwen3-Embedding inference from CPU-bound to GPU-bound +for batched workloads. + +```bash +# Linux / Windows + CUDA toolkit (12.x or 13.x) +cargo build --release -p vestige-mcp --features qwen3-embeddings,cuda + +# Optional cuDNN acceleration on top of CUDA +cargo build --release -p vestige-mcp --features qwen3-embeddings,cudnn + +VESTIGE_EMBEDDING_MODEL=qwen3-0.6b vestige consolidate +``` + +**Prerequisites:** + +- NVIDIA driver + CUDA toolkit (12.x or 13.x). Verify with `nvcc --version`. +- A C++ host compiler that `nvcc` can drive (Linux: `gcc`; Windows: MSVC / + `cl.exe` from a recent Visual Studio Build Tools install). + +**Windows + MSVC + CUDA 13.x build note.** Recent CCCL headers shipped with +CUDA 13.x require the modern preprocessor. Without it, the `candle-kernels` +`.cu` compile pass can fail at `cuda/include/cuda/std/__cccl/compiler.h`. Set +this env var before `cargo build` to pass `/Zc:preprocessor` through `nvcc`: + +```powershell +# PowerShell +$env:NVCC_PREPEND_FLAGS = '-Xcompiler="/Zc:preprocessor"' +cargo build --release -p vestige-mcp --features qwen3-embeddings,cuda +``` + +```cmd +:: cmd.exe +set NVCC_PREPEND_FLAGS=-Xcompiler="/Zc:preprocessor" +cargo build --release -p vestige-mcp --features qwen3-embeddings,cuda +``` + +Linux + CUDA 13.x builds with `gcc` do not need the equivalent flag. + +**Verifying GPU is actually used.** With CUDA-enabled builds, run +`VESTIGE_EMBEDDING_MODEL=qwen3-0.6b vestige consolidate` on a corpus of 1000+ +memories and watch `nvidia-smi`; embedding passes should pin a single GPU while +the run is active. + --- ## CLI diff --git a/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css b/apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css similarity index 74% rename from apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css rename to apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css index b0b4d99..f5bdd49 100644 --- a/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css +++ b/apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css @@ -1 +1 @@ -/*! tailwindcss v4.2.0 | MIT License | https://tailwindcss.com */@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--font-mono:"JetBrains Mono", "Fira Code", "SF Mono", monospace;--color-amber-400:oklch(82.8% .189 84.429);--color-purple-400:oklch(71.4% .203 305.504);--color-purple-500:oklch(62.7% .265 303.9);--color-black:#000;--color-white:#fff;--spacing:.25rem;--container-xs:20rem;--container-md:28rem;--container-lg:32rem;--container-xl:36rem;--container-2xl:42rem;--container-4xl:56rem;--container-5xl:64rem;--container-6xl:72rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height: 1.5 ;--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--text-3xl:1.875rem;--text-3xl--line-height: 1.2 ;--text-4xl:2.25rem;--text-4xl--line-height:calc(2.5 / 2.25);--text-5xl:3rem;--text-5xl--line-height:1;--text-6xl:3.75rem;--text-6xl--line-height:1;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--tracking-tight:-.025em;--tracking-wide:.025em;--tracking-wider:.05em;--tracking-widest:.1em;--leading-snug:1.375;--leading-relaxed:1.625;--radius-sm:.25rem;--radius-md:.375rem;--radius-lg:.5rem;--radius-xl:.75rem;--radius-2xl:1rem;--ease-out:cubic-bezier(0, 0, .2, 1);--ease-in-out:cubic-bezier(.4, 0, .2, 1);--animate-spin:spin 1s linear infinite;--animate-ping:ping 1s cubic-bezier(0, 0, .2, 1) infinite;--animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--blur-sm:8px;--blur-md:12px;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono);--color-void:#050510;--color-abyss:#0a0a1a;--color-deep:#10102a;--color-surface:#161638;--color-elevated:#1e1e4a;--color-subtle:#2a2a5e;--color-muted:#4a4a7a;--color-dim:#7a7aaa;--color-text:#e0e0ff;--color-bright:#fff;--color-synapse:#6366f1;--color-synapse-glow:#818cf8;--color-dream:#a855f7;--color-dream-glow:#c084fc;--color-memory:#3b82f6;--color-recall:#10b981;--color-decay:#ef4444;--color-warning:#f59e0b;--color-node-pattern:#ec4899}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;-moz-tab-size:4;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){-webkit-appearance:button;-moz-appearance:button;appearance:button}::file-selector-button{-webkit-appearance:button;-moz-appearance:button;appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}}@layer components;@layer utilities{.pointer-events-auto{pointer-events:auto}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.sticky{position:sticky}.inset-0{inset:calc(var(--spacing) * 0)}.inset-x-0{inset-inline:calc(var(--spacing) * 0)}.start{inset-inline-start:var(--spacing)}.end{inset-inline-end:var(--spacing)}.end\!{inset-inline-end:var(--spacing)!important}.top-0{top:calc(var(--spacing) * 0)}.top-0\.5{top:calc(var(--spacing) * .5)}.top-1{top:calc(var(--spacing) * 1)}.top-3{top:calc(var(--spacing) * 3)}.top-4{top:calc(var(--spacing) * 4)}.top-10{top:calc(var(--spacing) * 10)}.right-0{right:calc(var(--spacing) * 0)}.right-4{right:calc(var(--spacing) * 4)}.bottom-0{bottom:calc(var(--spacing) * 0)}.bottom-4{bottom:calc(var(--spacing) * 4)}.-left-\[29px\]{left:-29px}.left-1\/2{left:50%}.left-4{left:calc(var(--spacing) * 4)}.left-6{left:calc(var(--spacing) * 6)}.isolate{isolation:isolate}.z-10{z-index:10}.z-20{z-index:20}.z-40{z-index:40}.z-50{z-index:50}.z-\[1\]{z-index:1}.container{width:100%}@media(min-width:40rem){.container{max-width:40rem}}@media(min-width:48rem){.container{max-width:48rem}}@media(min-width:64rem){.container{max-width:64rem}}@media(min-width:80rem){.container{max-width:80rem}}@media(min-width:96rem){.container{max-width:96rem}}.mx-2{margin-inline:calc(var(--spacing) * 2)}.mx-auto{margin-inline:auto}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:calc(var(--spacing) * 1)}.mt-1\.5{margin-top:calc(var(--spacing) * 1.5)}.mt-2{margin-top:calc(var(--spacing) * 2)}.mt-3{margin-top:calc(var(--spacing) * 3)}.mt-4{margin-top:calc(var(--spacing) * 4)}.mt-\[-12px\]{margin-top:-12px}.mr-1{margin-right:calc(var(--spacing) * 1)}.mr-2{margin-right:calc(var(--spacing) * 2)}.mb-0\.5{margin-bottom:calc(var(--spacing) * .5)}.mb-1{margin-bottom:calc(var(--spacing) * 1)}.mb-1\.5{margin-bottom:calc(var(--spacing) * 1.5)}.mb-2{margin-bottom:calc(var(--spacing) * 2)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.mb-4{margin-bottom:calc(var(--spacing) * 4)}.ml-2{margin-left:calc(var(--spacing) * 2)}.ml-3{margin-left:calc(var(--spacing) * 3)}.ml-auto{margin-left:auto}.line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-4{-webkit-line-clamp:4;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.block{display:block}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-flex{display:inline-flex}.table{display:table}.aspect-square{aspect-ratio:1}.h-0\.5{height:calc(var(--spacing) * .5)}.h-1{height:calc(var(--spacing) * 1)}.h-1\.5{height:calc(var(--spacing) * 1.5)}.h-2{height:calc(var(--spacing) * 2)}.h-2\.5{height:calc(var(--spacing) * 2.5)}.h-3{height:calc(var(--spacing) * 3)}.h-4{height:calc(var(--spacing) * 4)}.h-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-12{height:calc(var(--spacing) * 12)}.h-14{height:calc(var(--spacing) * 14)}.h-16{height:calc(var(--spacing) * 16)}.h-20{height:calc(var(--spacing) * 20)}.h-24{height:calc(var(--spacing) * 24)}.h-28{height:calc(var(--spacing) * 28)}.h-32{height:calc(var(--spacing) * 32)}.h-40{height:calc(var(--spacing) * 40)}.h-\[520px\]{height:520px}.h-\[560px\]{height:560px}.h-full{height:100%}.h-px{height:1px}.h-screen{height:100vh}.max-h-48{max-height:calc(var(--spacing) * 48)}.max-h-64{max-height:calc(var(--spacing) * 64)}.max-h-72{max-height:calc(var(--spacing) * 72)}.max-h-96{max-height:calc(var(--spacing) * 96)}.max-h-\[620px\]{max-height:620px}.min-h-0{min-height:calc(var(--spacing) * 0)}.min-h-40{min-height:calc(var(--spacing) * 40)}.min-h-\[240px\]{min-height:240px}.min-h-\[320px\]{min-height:320px}.min-h-\[520px\]{min-height:520px}.min-h-full{min-height:100%}.w-1\.5{width:calc(var(--spacing) * 1.5)}.w-2{width:calc(var(--spacing) * 2)}.w-2\.5{width:calc(var(--spacing) * 2.5)}.w-3{width:calc(var(--spacing) * 3)}.w-4{width:calc(var(--spacing) * 4)}.w-5{width:calc(var(--spacing) * 5)}.w-6{width:calc(var(--spacing) * 6)}.w-7{width:calc(var(--spacing) * 7)}.w-8{width:calc(var(--spacing) * 8)}.w-9{width:calc(var(--spacing) * 9)}.w-12{width:calc(var(--spacing) * 12)}.w-14{width:calc(var(--spacing) * 14)}.w-16{width:calc(var(--spacing) * 16)}.w-20{width:calc(var(--spacing) * 20)}.w-24{width:calc(var(--spacing) * 24)}.w-32{width:calc(var(--spacing) * 32)}.w-96{width:calc(var(--spacing) * 96)}.w-\[3px\]{width:3px}.w-\[90\%\]{width:90%}.w-full{width:100%}.w-px{width:1px}.max-w-2xl{max-width:var(--container-2xl)}.max-w-4xl{max-width:var(--container-4xl)}.max-w-5xl{max-width:var(--container-5xl)}.max-w-6xl{max-width:var(--container-6xl)}.max-w-7xl{max-width:var(--container-7xl)}.max-w-20{max-width:calc(var(--spacing) * 20)}.max-w-\[220px\]{max-width:220px}.max-w-lg{max-width:var(--container-lg)}.max-w-md{max-width:var(--container-md)}.max-w-xl{max-width:var(--container-xl)}.max-w-xs{max-width:var(--container-xs)}.min-w-0{min-width:calc(var(--spacing) * 0)}.min-w-12{min-width:calc(var(--spacing) * 12)}.min-w-16{min-width:calc(var(--spacing) * 16)}.min-w-64{min-width:calc(var(--spacing) * 64)}.min-w-\[2rem\]{min-width:2rem}.min-w-\[3\.5rem\]{min-width:3.5rem}.flex-1{flex:1}.flex-shrink{flex-shrink:1}.flex-shrink-0{flex-shrink:0}.shrink{flex-shrink:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.border-separate{border-collapse:separate}.-translate-x-1\/2{--tw-translate-x: -50% ;translate:var(--tw-translate-x) var(--tw-translate-y)}.scale-125{--tw-scale-x:125%;--tw-scale-y:125%;--tw-scale-z:125%;scale:var(--tw-scale-x) var(--tw-scale-y)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.animate-\[fadeSlide_0\.35s_ease-out_both\]{animation:.35s ease-out both fadeSlide}.animate-ping{animation:var(--animate-ping)}.animate-pulse{animation:var(--animate-pulse)}.animate-spin{animation:var(--animate-spin)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.resize{resize:both}.resize-none{resize:none}.resize-y{resize:vertical}.appearance-none{-webkit-appearance:none;-moz-appearance:none;appearance:none}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.grid-cols-7{grid-template-columns:repeat(7,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-baseline{align-items:baseline}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-around{justify-content:space-around}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.gap-0{gap:calc(var(--spacing) * 0)}.gap-0\.5{gap:calc(var(--spacing) * .5)}.gap-1{gap:calc(var(--spacing) * 1)}.gap-1\.5{gap:calc(var(--spacing) * 1.5)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}.gap-4{gap:calc(var(--spacing) * 4)}.gap-5{gap:calc(var(--spacing) * 5)}.gap-6{gap:calc(var(--spacing) * 6)}.gap-\[2px\]{gap:2px}:where(.space-y-0\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * .5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * .5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1.5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1.5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 4) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 4) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 6) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-8>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 8) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 8) * calc(1 - var(--tw-space-y-reverse)))}.gap-x-6{column-gap:calc(var(--spacing) * 6)}.gap-y-1{row-gap:calc(var(--spacing) * 1)}.self-center{align-self:center}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:var(--radius-2xl)}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius-lg)}.rounded-md{border-radius:var(--radius-md)}.rounded-sm{border-radius:var(--radius-sm)}.rounded-xl{border-radius:var(--radius-xl)}.rounded-t{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.border{border-style:var(--tw-border-style);border-width:1px}.border-2{border-style:var(--tw-border-style);border-width:2px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.\!border-decay\/20{border-color:#ef444433!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)!important}}.\!border-decay\/30{border-color:#ef44444d!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/30{border-color:color-mix(in oklab,var(--color-decay) 30%,transparent)!important}}.\!border-decay\/40{border-color:#ef444466!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/40{border-color:color-mix(in oklab,var(--color-decay) 40%,transparent)!important}}.\!border-dream\/20{border-color:#a855f733!important}@supports (color:color-mix(in lab,red,red)){.\!border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)!important}}.\!border-synapse\/15{border-color:#6366f126!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)!important}}.\!border-synapse\/20{border-color:#6366f133!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)!important}}.\!border-synapse\/25{border-color:#6366f140!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/25{border-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)!important}}.\!border-synapse\/30{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.\!border-synapse\/40{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.border-\[\#A33FFF\]\/40{border-color:#a33fff66}.border-decay\/20{border-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.border-dream-glow\/40{border-color:#c084fc66}@supports (color:color-mix(in lab,red,red)){.border-dream-glow\/40{border-color:color-mix(in oklab,var(--color-dream-glow) 40%,transparent)}}.border-dream\/10{border-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.border-dream\/10{border-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.border-dream\/20{border-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.border-dream\/30{border-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.border-dream\/30{border-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.border-dream\/40{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.border-dream\/40{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.border-dream\/50{border-color:#a855f780}@supports (color:color-mix(in lab,red,red)){.border-dream\/50{border-color:color-mix(in oklab,var(--color-dream) 50%,transparent)}}.border-recall\/30{border-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.border-recall\/30{border-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.border-recall\/40{border-color:#10b98166}@supports (color:color-mix(in lab,red,red)){.border-recall\/40{border-color:color-mix(in oklab,var(--color-recall) 40%,transparent)}}.border-subtle\/15{border-color:#2a2a5e26}@supports (color:color-mix(in lab,red,red)){.border-subtle\/15{border-color:color-mix(in oklab,var(--color-subtle) 15%,transparent)}}.border-subtle\/20{border-color:#2a2a5e33}@supports (color:color-mix(in lab,red,red)){.border-subtle\/20{border-color:color-mix(in oklab,var(--color-subtle) 20%,transparent)}}.border-subtle\/30{border-color:#2a2a5e4d}@supports (color:color-mix(in lab,red,red)){.border-subtle\/30{border-color:color-mix(in oklab,var(--color-subtle) 30%,transparent)}}.border-synapse{border-color:var(--color-synapse)}.border-synapse\/5{border-color:#6366f10d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/5{border-color:color-mix(in oklab,var(--color-synapse) 5%,transparent)}}.border-synapse\/10{border-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.border-synapse\/10{border-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.border-synapse\/15{border-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.border-synapse\/20{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.border-synapse\/30{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.border-synapse\/40{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.border-transparent{border-color:#0000}.border-warning\/30{border-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.border-warning\/30{border-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.border-warning\/40{border-color:#f59e0b66}@supports (color:color-mix(in lab,red,red)){.border-warning\/40{border-color:color-mix(in oklab,var(--color-warning) 40%,transparent)}}.border-warning\/50{border-color:#f59e0b80}@supports (color:color-mix(in lab,red,red)){.border-warning\/50{border-color:color-mix(in oklab,var(--color-warning) 50%,transparent)}}.border-white\/5{border-color:#ffffff0d}@supports (color:color-mix(in lab,red,red)){.border-white\/5{border-color:color-mix(in oklab,var(--color-white) 5%,transparent)}}.border-t-dream{border-top-color:var(--color-dream)}.border-t-synapse{border-top-color:var(--color-synapse)}.border-t-warning{border-top-color:var(--color-warning)}.bg-\[\#A33FFF\]{background-color:#a33fff}.bg-\[\#A33FFF\]\/10{background-color:#a33fff1a}.bg-amber-400{background-color:var(--color-amber-400)}.bg-black\/40{background-color:#0006}@supports (color:color-mix(in lab,red,red)){.bg-black\/40{background-color:color-mix(in oklab,var(--color-black) 40%,transparent)}}.bg-decay{background-color:var(--color-decay)}.bg-decay\/10{background-color:#ef44441a}@supports (color:color-mix(in lab,red,red)){.bg-decay\/10{background-color:color-mix(in oklab,var(--color-decay) 10%,transparent)}}.bg-decay\/20{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.bg-decay\/20{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.bg-decay\/\[0\.05\]{background-color:#ef44440d}@supports (color:color-mix(in lab,red,red)){.bg-decay\/\[0\.05\]{background-color:color-mix(in oklab,var(--color-decay) 5%,transparent)}}.bg-deep{background-color:var(--color-deep)}.bg-deep\/40{background-color:#10102a66}@supports (color:color-mix(in lab,red,red)){.bg-deep\/40{background-color:color-mix(in oklab,var(--color-deep) 40%,transparent)}}.bg-deep\/60{background-color:#10102a99}@supports (color:color-mix(in lab,red,red)){.bg-deep\/60{background-color:color-mix(in oklab,var(--color-deep) 60%,transparent)}}.bg-dream{background-color:var(--color-dream)}.bg-dream\/5{background-color:#a855f70d}@supports (color:color-mix(in lab,red,red)){.bg-dream\/5{background-color:color-mix(in oklab,var(--color-dream) 5%,transparent)}}.bg-dream\/10{background-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.bg-dream\/10{background-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.bg-dream\/15{background-color:#a855f726}@supports (color:color-mix(in lab,red,red)){.bg-dream\/15{background-color:color-mix(in oklab,var(--color-dream) 15%,transparent)}}.bg-dream\/20{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.bg-dream\/20{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.bg-muted{background-color:var(--color-muted)}.bg-node-pattern{background-color:var(--color-node-pattern)}.bg-purple-500\/20{background-color:#ac4bff33}@supports (color:color-mix(in lab,red,red)){.bg-purple-500\/20{background-color:color-mix(in oklab,var(--color-purple-500) 20%,transparent)}}.bg-recall{background-color:var(--color-recall)}.bg-recall\/10{background-color:#10b9811a}@supports (color:color-mix(in lab,red,red)){.bg-recall\/10{background-color:color-mix(in oklab,var(--color-recall) 10%,transparent)}}.bg-recall\/15{background-color:#10b98126}@supports (color:color-mix(in lab,red,red)){.bg-recall\/15{background-color:color-mix(in oklab,var(--color-recall) 15%,transparent)}}.bg-recall\/20{background-color:#10b98133}@supports (color:color-mix(in lab,red,red)){.bg-recall\/20{background-color:color-mix(in oklab,var(--color-recall) 20%,transparent)}}.bg-synapse{background-color:var(--color-synapse)}.bg-synapse-glow{background-color:var(--color-synapse-glow)}.bg-synapse\/10{background-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/10{background-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.bg-synapse\/15{background-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/15{background-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.bg-synapse\/20{background-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/20{background-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.bg-synapse\/25{background-color:#6366f140}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/25{background-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)}}.bg-synapse\/70{background-color:#6366f1b3}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/70{background-color:color-mix(in oklab,var(--color-synapse) 70%,transparent)}}.bg-transparent{background-color:#0000}.bg-void{background-color:var(--color-void)}.bg-void\/60{background-color:#05051099}@supports (color:color-mix(in lab,red,red)){.bg-void\/60{background-color:color-mix(in oklab,var(--color-void) 60%,transparent)}}.bg-warning{background-color:var(--color-warning)}.bg-warning\/5{background-color:#f59e0b0d}@supports (color:color-mix(in lab,red,red)){.bg-warning\/5{background-color:color-mix(in oklab,var(--color-warning) 5%,transparent)}}.bg-warning\/20{background-color:#f59e0b33}@supports (color:color-mix(in lab,red,red)){.bg-warning\/20{background-color:color-mix(in oklab,var(--color-warning) 20%,transparent)}}.bg-white\/\[0\.02\]{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.02\]{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.bg-white\/\[0\.03\]{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.03\]{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.bg-white\/\[0\.04\]{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.04\]{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.bg-white\/\[0\.06\]{background-color:#ffffff0f}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.06\]{background-color:color-mix(in oklab,var(--color-white) 6%,transparent)}}.bg-gradient-to-br{--tw-gradient-position:to bottom right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.from-dream{--tw-gradient-from:var(--color-dream);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.to-synapse{--tw-gradient-to:var(--color-synapse);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.p-0{padding:calc(var(--spacing) * 0)}.p-0\.5{padding:calc(var(--spacing) * .5)}.p-1{padding:calc(var(--spacing) * 1)}.p-2{padding:calc(var(--spacing) * 2)}.p-2\.5{padding:calc(var(--spacing) * 2.5)}.p-3{padding:calc(var(--spacing) * 3)}.p-4{padding:calc(var(--spacing) * 4)}.p-5{padding:calc(var(--spacing) * 5)}.p-6{padding:calc(var(--spacing) * 6)}.p-10{padding:calc(var(--spacing) * 10)}.p-12{padding:calc(var(--spacing) * 12)}.px-1{padding-inline:calc(var(--spacing) * 1)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-2\.5{padding-inline:calc(var(--spacing) * 2.5)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.px-5{padding-inline:calc(var(--spacing) * 5)}.px-6{padding-inline:calc(var(--spacing) * 6)}.px-8{padding-inline:calc(var(--spacing) * 8)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1{padding-block:calc(var(--spacing) * 1)}.py-1\.5{padding-block:calc(var(--spacing) * 1.5)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-3{padding-block:calc(var(--spacing) * 3)}.py-4{padding-block:calc(var(--spacing) * 4)}.py-5{padding-block:calc(var(--spacing) * 5)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.py-10{padding-block:calc(var(--spacing) * 10)}.py-12{padding-block:calc(var(--spacing) * 12)}.py-20{padding-block:calc(var(--spacing) * 20)}.pt-1{padding-top:calc(var(--spacing) * 1)}.pt-2{padding-top:calc(var(--spacing) * 2)}.pt-3{padding-top:calc(var(--spacing) * 3)}.pt-4{padding-top:calc(var(--spacing) * 4)}.pt-6{padding-top:calc(var(--spacing) * 6)}.pt-8{padding-top:calc(var(--spacing) * 8)}.pt-\[10vh\]{padding-top:10vh}.pr-1{padding-right:calc(var(--spacing) * 1)}.pr-2{padding-right:calc(var(--spacing) * 2)}.pb-2{padding-bottom:calc(var(--spacing) * 2)}.pb-16{padding-bottom:calc(var(--spacing) * 16)}.pl-6{padding-left:calc(var(--spacing) * 6)}.pl-14{padding-left:calc(var(--spacing) * 14)}.text-center{text-align:center}.text-left{text-align:left}.text-right{text-align:right}.align-bottom{vertical-align:bottom}.align-top{vertical-align:top}.font-mono{font-family:var(--font-mono)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-3xl{font-size:var(--text-3xl);line-height:var(--tw-leading,var(--text-3xl--line-height))}.text-4xl{font-size:var(--text-4xl);line-height:var(--tw-leading,var(--text-4xl--line-height))}.text-5xl{font-size:var(--text-5xl);line-height:var(--tw-leading,var(--text-5xl--line-height))}.text-6xl{font-size:var(--text-6xl);line-height:var(--tw-leading,var(--text-6xl--line-height))}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[8px\]{font-size:8px}.text-\[9px\]{font-size:9px}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.leading-none{--tw-leading:1;line-height:1}.leading-relaxed{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.font-bold{--tw-font-weight:var(--font-weight-bold);font-weight:var(--font-weight-bold)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-\[0\.12em\]{--tw-tracking:.12em;letter-spacing:.12em}.tracking-\[0\.15em\]{--tw-tracking:.15em;letter-spacing:.15em}.tracking-\[0\.18em\]{--tw-tracking:.18em;letter-spacing:.18em}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.tracking-wide{--tw-tracking:var(--tracking-wide);letter-spacing:var(--tracking-wide)}.tracking-wider{--tw-tracking:var(--tracking-wider);letter-spacing:var(--tracking-wider)}.tracking-widest{--tw-tracking:var(--tracking-widest);letter-spacing:var(--tracking-widest)}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.text-\[\#E4C8FF\]{color:#e4c8ff}.text-amber-400{color:var(--color-amber-400)}.text-bright{color:var(--color-bright)}.text-decay{color:var(--color-decay)}.text-decay\/60{color:#ef444499}@supports (color:color-mix(in lab,red,red)){.text-decay\/60{color:color-mix(in oklab,var(--color-decay) 60%,transparent)}}.text-dim{color:var(--color-dim)}.text-dream{color:var(--color-dream)}.text-dream-glow{color:var(--color-dream-glow)}.text-dream\/40{color:#a855f766}@supports (color:color-mix(in lab,red,red)){.text-dream\/40{color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.text-dream\/80{color:#a855f7cc}@supports (color:color-mix(in lab,red,red)){.text-dream\/80{color:color-mix(in oklab,var(--color-dream) 80%,transparent)}}.text-memory{color:var(--color-memory)}.text-muted{color:var(--color-muted)}.text-muted\/50{color:#4a4a7a80}@supports (color:color-mix(in lab,red,red)){.text-muted\/50{color:color-mix(in oklab,var(--color-muted) 50%,transparent)}}.text-muted\/60{color:#4a4a7a99}@supports (color:color-mix(in lab,red,red)){.text-muted\/60{color:color-mix(in oklab,var(--color-muted) 60%,transparent)}}.text-node-pattern{color:var(--color-node-pattern)}.text-purple-400{color:var(--color-purple-400)}.text-recall{color:var(--color-recall)}.text-subtle{color:var(--color-subtle)}.text-synapse{color:var(--color-synapse)}.text-synapse-glow{color:var(--color-synapse-glow)}.text-text{color:var(--color-text)}.text-text\/80{color:#e0e0ffcc}@supports (color:color-mix(in lab,red,red)){.text-text\/80{color:color-mix(in oklab,var(--color-text) 80%,transparent)}}.text-warning{color:var(--color-warning)}.capitalize{text-transform:capitalize}.uppercase{text-transform:uppercase}.italic{font-style:italic}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.underline-offset-4{text-underline-offset:4px}.accent-synapse{accent-color:var(--color-synapse)}.accent-synapse-glow{accent-color:var(--color-synapse-glow)}.opacity-20{opacity:.2}.opacity-30{opacity:.3}.opacity-35{opacity:.35}.opacity-40{opacity:.4}.opacity-60{opacity:.6}.opacity-75{opacity:.75}.opacity-100{opacity:1}.shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow\!{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a)!important;box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)!important}.shadow-2xl{--tw-shadow:0 25px 50px -12px var(--tw-shadow-color,#00000040);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_10px_rgba\(239\,68\,68\,0\.7\)\]{--tw-shadow:0 0 10px var(--tw-shadow-color,#ef4444b3);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f126);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.18\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f12e);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(163\,63\,255\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#a33fff26);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(99\,102\,241\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#6366f14d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(168\,85\,247\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#a855f74d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a), 0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring,.ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-2{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-synapse\/10{--tw-shadow-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/10{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 10%, transparent) var(--tw-shadow-alpha), transparent)}}.shadow-synapse\/20{--tw-shadow-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/20{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 20%, transparent) var(--tw-shadow-alpha), transparent)}}.ring-dream-glow{--tw-ring-color:var(--color-dream-glow)}.ring-dream\/60{--tw-ring-color:#a855f799}@supports (color:color-mix(in lab,red,red)){.ring-dream\/60{--tw-ring-color:color-mix(in oklab, var(--color-dream) 60%, transparent)}}.ring-recall\/30{--tw-ring-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.ring-recall\/30{--tw-ring-color:color-mix(in oklab, var(--color-recall) 30%, transparent)}}.ring-synapse\/60{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.ring-synapse\/60{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.blur{--tw-blur:blur(8px);filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.backdrop-blur-md{--tw-backdrop-blur:blur(var(--blur-md));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-blur-sm{--tw-backdrop-blur:blur(var(--blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-filter{-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-200{--tw-duration:.2s;transition-duration:.2s}.duration-300{--tw-duration:.3s;transition-duration:.3s}.duration-500{--tw-duration:.5s;transition-duration:.5s}.duration-700{--tw-duration:.7s;transition-duration:.7s}.ease-in-out{--tw-ease:var(--ease-in-out);transition-timing-function:var(--ease-in-out)}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}.select-none{-webkit-user-select:none;user-select:none}.placeholder\:text-muted::placeholder{color:var(--color-muted)}@media(hover:hover){.hover\:z-10:hover{z-index:10}.hover\:scale-110:hover{--tw-scale-x:110%;--tw-scale-y:110%;--tw-scale-z:110%;scale:var(--tw-scale-x) var(--tw-scale-y)}.hover\:scale-\[1\.03\]:hover{scale:1.03}.hover\:\!border-synapse\/30:hover{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.hover\:\!border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.hover\:border-synapse\/20:hover{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/20:hover{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.hover\:border-synapse\/30:hover{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:border-synapse\/50:hover{border-color:#6366f180}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/50:hover{border-color:color-mix(in oklab,var(--color-synapse) 50%,transparent)}}.hover\:bg-decay\/20:hover{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/20:hover{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.hover\:bg-decay\/30:hover{background-color:#ef44444d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/30:hover{background-color:color-mix(in oklab,var(--color-decay) 30%,transparent)}}.hover\:bg-dream\/20:hover{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/20:hover{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.hover\:bg-dream\/30:hover{background-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/30:hover{background-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.hover\:bg-purple-500\/30:hover{background-color:#ac4bff4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-purple-500\/30:hover{background-color:color-mix(in oklab,var(--color-purple-500) 30%,transparent)}}.hover\:bg-recall\/30:hover{background-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-recall\/30:hover{background-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.hover\:bg-synapse\/30:hover{background-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-synapse\/30:hover{background-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:bg-warning\/30:hover{background-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-warning\/30:hover{background-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.hover\:bg-white\/\[0\.02\]:hover{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.02\]:hover{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.hover\:bg-white\/\[0\.03\]:hover{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.03\]:hover{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.hover\:bg-white\/\[0\.04\]:hover{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.04\]:hover{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.hover\:bg-white\/\[0\.08\]:hover{background-color:#ffffff14}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.08\]:hover{background-color:color-mix(in oklab,var(--color-white) 8%,transparent)}}.hover\:text-bright:hover{color:var(--color-bright)}.hover\:text-dim:hover{color:var(--color-dim)}.hover\:text-synapse-glow:hover{color:var(--color-synapse-glow)}.hover\:text-text:hover{color:var(--color-text)}.hover\:underline:hover{text-decoration-line:underline}}.focus\:\!border-synapse\/40:focus{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.focus\:\!border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.focus\:border-dream\/40:focus{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.focus\:border-dream\/40:focus{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.focus\:border-synapse\/40:focus{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.focus\:border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.focus\:ring-1:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-synapse-glow:focus{--tw-ring-color:var(--color-synapse-glow)}.focus\:ring-synapse\/20:focus{--tw-ring-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.focus\:ring-synapse\/20:focus{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 20%, transparent)}}.focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:#c084fc99}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-dream-glow) 60%, transparent)}}.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:#10b98199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-recall) 60%, transparent)}}.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-40:disabled{opacity:.4}.disabled\:opacity-50:disabled{opacity:.5}@media(min-width:40rem){.sm\:block{display:block}.sm\:inline-flex{display:inline-flex}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}}@media(min-width:48rem){.md\:block{display:block}.md\:flex{display:flex}.md\:hidden{display:none}.md\:inline-flex{display:inline-flex}.md\:min-w-\[340px\]{min-width:340px}.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.md\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.md\:grid-cols-5{grid-template-columns:repeat(5,minmax(0,1fr))}.md\:grid-cols-\[1fr_auto\]{grid-template-columns:1fr auto}.md\:grid-cols-\[280px_1fr\]{grid-template-columns:280px 1fr}.md\:flex-row{flex-direction:row}.md\:pt-\[15vh\]{padding-top:15vh}.md\:pb-0{padding-bottom:calc(var(--spacing) * 0)}}@media(min-width:64rem){.lg\:block{display:block}.lg\:w-56{width:calc(var(--spacing) * 56)}.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.lg\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.lg\:grid-cols-\[1fr_280px\]{grid-template-columns:1fr 280px}.lg\:grid-cols-\[1fr_340px\]{grid-template-columns:1fr 340px}.lg\:grid-cols-\[1fr_360px\]{grid-template-columns:1fr 360px}.lg\:grid-cols-\[minmax\(0\,1fr\)_340px\]{grid-template-columns:minmax(0,1fr) 340px}}.\[\&\:\:-webkit-slider-thumb\]\:h-3::-webkit-slider-thumb{height:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:w-3::-webkit-slider-thumb{width:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:appearance-none::-webkit-slider-thumb{-webkit-appearance:none;-moz-appearance:none;appearance:none}.\[\&\:\:-webkit-slider-thumb\]\:rounded-full::-webkit-slider-thumb{border-radius:3.40282e38px}.\[\&\:\:-webkit-slider-thumb\]\:bg-synapse-glow::-webkit-slider-thumb{background-color:var(--color-synapse-glow)}.\[\&\:\:-webkit-slider-thumb\]\:shadow-\[0_0_8px_rgba\(129\,140\,248\,0\.4\)\]::-webkit-slider-thumb{--tw-shadow:0 0 8px var(--tw-shadow-color,#818cf866);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}}html{background:var(--color-void);color:var(--color-text);font-family:var(--font-mono)}body{min-height:100vh;margin:0;overflow:hidden}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:var(--color-subtle);border-radius:3px}::-webkit-scrollbar-thumb:hover{background:var(--color-muted)}.glass{-webkit-backdrop-filter:blur(20px)saturate(180%);background:#16163873;border:1px solid #6366f114;box-shadow:inset 0 1px #ffffff08,0 4px 24px #0000004d}.glass-subtle{-webkit-backdrop-filter:blur(12px)saturate(150%);background:#10102a66;border:1px solid #6366f10f;box-shadow:inset 0 1px #ffffff05,0 2px 12px #0003}.glass-sidebar{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1a99;border-right:1px solid #6366f11a;box-shadow:inset -1px 0 #ffffff05,4px 0 24px #0000004d}.glass-panel{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1acc;border:1px solid #6366f11a;box-shadow:inset 0 1px #ffffff08,0 8px 32px #0006}.glow-synapse{box-shadow:0 0 20px #6366f14d,0 0 60px #6366f11a}.glow-dream{box-shadow:0 0 20px #a855f74d,0 0 60px #a855f71a}.glow-memory{box-shadow:0 0 20px #3b82f64d,0 0 60px #3b82f61a}@keyframes pulse-glow{0%,to{opacity:1}50%{opacity:.5}}.animate-pulse-glow{animation:2s ease-in-out infinite pulse-glow}@keyframes orb-float-1{0%,to{transform:translate(0)scale(1)}25%{transform:translate(60px,-40px)scale(1.1)}50%{transform:translate(-30px,-80px)scale(.95)}75%{transform:translate(-60px,-20px)scale(1.05)}}@keyframes orb-float-2{0%,to{transform:translate(0)scale(1)}25%{transform:translate(-50px,30px)scale(1.08)}50%{transform:translate(40px,60px)scale(.92)}75%{transform:translate(20px,-40px)scale(1.03)}}@keyframes orb-float-3{0%,to{transform:translate(0)scale(1)}25%{transform:translate(30px,50px)scale(1.05)}50%{transform:translate(-60px,20px)scale(.98)}75%{transform:translate(40px,-30px)scale(1.1)}}.ambient-orb{filter:blur(80px);pointer-events:none;z-index:0;opacity:.35;border-radius:50%;position:fixed}.ambient-orb-1{background:radial-gradient(circle,#a855f766,#0000 70%);width:400px;height:400px;animation:20s ease-in-out infinite orb-float-1;top:-10%;right:-5%}.ambient-orb-2{background:radial-gradient(circle,#6366f159,#0000 70%);width:350px;height:350px;animation:25s ease-in-out infinite orb-float-2;bottom:-15%;left:-5%}.ambient-orb-3{background:radial-gradient(circle,#f59e0b33,#0000 70%);width:300px;height:300px;animation:22s ease-in-out infinite orb-float-3;top:40%;left:40%}.nav-active-border{position:relative}.nav-active-border:before{content:"";background:linear-gradient(180deg,var(--color-synapse),var(--color-dream),var(--color-synapse));background-size:100% 200%;border-radius:1px;width:2px;animation:3s ease-in-out infinite gradient-shift;position:absolute;top:4px;bottom:4px;left:0}@keyframes gradient-shift{0%,to{background-position:0 0}50%{background-position:0 100%}}@keyframes float{0%,to{transform:translateY(0)translate(0)}25%{transform:translateY(-10px)translate(5px)}50%{transform:translateY(-5px)translate(-5px)}75%{transform:translateY(-15px)translate(3px)}}.retention-critical{color:var(--color-decay)}.retention-low{color:var(--color-warning)}.retention-good{color:var(--color-recall)}.retention-strong{color:var(--color-synapse)}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@keyframes spin{to{transform:rotate(360deg)}}@keyframes ping{75%,to{opacity:0;transform:scale(2)}}@keyframes pulse{50%{opacity:.5}}.toast-layer.svelte-pry2ep{position:fixed;z-index:60;pointer-events:none;display:flex;flex-direction:column;gap:.5rem;right:1.25rem;bottom:1.25rem;max-width:22rem;width:calc(100vw - 2.5rem)}@media(max-width:768px){.toast-layer.svelte-pry2ep{right:.75rem;left:.75rem;bottom:auto;top:5.25rem;max-width:none;width:auto;align-items:stretch}}.toast-item.svelte-pry2ep{pointer-events:auto;position:relative;display:flex;gap:.75rem;align-items:stretch;text-align:left;font:inherit;color:inherit;background:#0c0e16b8;backdrop-filter:blur(14px) saturate(160%);-webkit-backdrop-filter:blur(14px) saturate(160%);border:1px solid rgba(255,255,255,.06);border-radius:.75rem;padding:.75rem .9rem .75rem .5rem;overflow:hidden;box-shadow:0 10px 40px -12px #000c,0 0 22px -6px var(--toast-color);cursor:pointer;animation:svelte-pry2ep-toast-in .32s cubic-bezier(.16,1,.3,1);transform-origin:right center;transition:transform .15s ease,box-shadow .15s ease}.toast-item.svelte-pry2ep:hover{transform:translateY(-1px) scale(1.015);box-shadow:0 14px 48px -12px #000000d9,0 0 32px -4px var(--toast-color)}.toast-item.svelte-pry2ep:focus-visible{outline:1px solid var(--toast-color);outline-offset:2px}.toast-accent.svelte-pry2ep{width:3px;border-radius:2px;background:var(--toast-color);box-shadow:0 0 10px var(--toast-color);flex-shrink:0}.toast-body.svelte-pry2ep{display:flex;flex-direction:column;gap:.15rem;flex:1;min-width:0}.toast-head.svelte-pry2ep{display:flex;align-items:center;gap:.5rem}.toast-icon.svelte-pry2ep{color:var(--toast-color);font-size:.95rem;text-shadow:0 0 8px var(--toast-color);line-height:1;width:1rem;display:inline-flex;justify-content:center}.toast-title.svelte-pry2ep{color:#f5f5fa;font-size:.82rem;font-weight:600;letter-spacing:.01em}.toast-sub.svelte-pry2ep{color:#b0b6c4;font-size:.74rem;line-height:1.35;padding-left:1.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.toast-progress.svelte-pry2ep{position:absolute;left:0;bottom:0;height:2px;width:100%;background:#ffffff0a}.toast-progress-fill.svelte-pry2ep{height:100%;background:var(--toast-color);opacity:.55;transform-origin:left center;animation:svelte-pry2ep-toast-progress var(--toast-dwell) linear forwards}.toast-item.svelte-pry2ep:hover .toast-progress-fill:where(.svelte-pry2ep),.toast-item.svelte-pry2ep:focus-visible .toast-progress-fill:where(.svelte-pry2ep){animation-play-state:paused}@keyframes svelte-pry2ep-toast-in{0%{opacity:0;transform:translate(24px) scale(.98)}to{opacity:1;transform:translate(0) scale(1)}}@media(max-width:768px){.toast-item.svelte-pry2ep{transform-origin:top center;animation:svelte-pry2ep-toast-in-mobile .3s cubic-bezier(.16,1,.3,1)}}@keyframes svelte-pry2ep-toast-in-mobile{0%{opacity:0;transform:translateY(-12px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}@keyframes svelte-pry2ep-toast-progress{0%{transform:scaleX(1)}to{transform:scaleX(0)}}@media(prefers-reduced-motion:reduce){.toast-item.svelte-pry2ep{animation:none}.toast-progress-fill.svelte-pry2ep{animation:none;transform:scaleX(.5)}}.strip-item.svelte-1kk3799{display:inline-flex;align-items:center;gap:.4rem;padding:0 .75rem;white-space:nowrap;flex-shrink:0}.strip-divider.svelte-1kk3799{width:1px;height:14px;background:#6366f11f;flex-shrink:0}.ambient-strip.ambient-flash.svelte-1kk3799{background:linear-gradient(90deg,#ef444414,#ef444400 70%),#0006;border-bottom-color:#ef444459;transition:background .3s ease,border-color .3s ease}@keyframes svelte-1kk3799-ping-slow{0%{transform:scale(1);opacity:.8}80%,to{transform:scale(2);opacity:0}}.animate-ping-slow{animation:svelte-1kk3799-ping-slow 2.2s cubic-bezier(0,0,.2,1) infinite}@media(prefers-reduced-motion:reduce){.ambient-strip.svelte-1kk3799 .animate-ping,.ambient-strip.svelte-1kk3799 .animate-ping-slow,.ambient-strip.svelte-1kk3799 .animate-pulse{animation:none!important}}.verdict-bar.svelte-1j425e6{border-bottom:1px solid rgba(255,255,255,.06);background:#080912b8;backdrop-filter:blur(18px) saturate(160%);-webkit-backdrop-filter:blur(18px) saturate(160%);box-shadow:0 6px 24px #0000002e}.verdict-summary.svelte-1j425e6{width:100%;min-height:2.75rem;display:grid;grid-template-columns:auto auto minmax(0,1fr) auto;align-items:center;gap:.75rem;padding:.55rem 1rem;color:var(--color-text);text-align:left;font:inherit}.sr-only.svelte-1j425e6{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.label.svelte-1j425e6,.field-label.svelte-1j425e6,.appeal-row.svelte-1j425e6>span:where(.svelte-1j425e6){color:var(--color-dim);font-size:.68rem;text-transform:uppercase;letter-spacing:0}.levels.svelte-1j425e6{display:flex;align-items:center;gap:.25rem}.levels.svelte-1j425e6 span:where(.svelte-1j425e6){border:1px solid rgba(255,255,255,.08);border-radius:.35rem;padding:.18rem .38rem;color:var(--color-muted);font-size:.64rem;line-height:1}.levels.svelte-1j425e6 span.active:where(.svelte-1j425e6){color:var(--color-bright);border-color:var(--verdict-color);background:color-mix(in srgb,var(--verdict-color) 18%,transparent);box-shadow:0 0 14px color-mix(in srgb,var(--verdict-color) 28%,transparent)}.summary-text.svelte-1j425e6{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.78rem;color:var(--color-dim)}.when.svelte-1j425e6{color:var(--color-muted);font-size:.68rem}.receipt.svelte-1j425e6{margin:0 1rem .75rem;border:1px solid rgba(255,255,255,.08);border-radius:.5rem;background:#0a0a1ac7;padding:.85rem}.receipt-grid.svelte-1j425e6{display:grid;grid-template-columns:minmax(0,1.4fr) minmax(10rem,.8fr) minmax(0,1.1fr) minmax(0,1.1fr);gap:.85rem}.receipt.svelte-1j425e6 p:where(.svelte-1j425e6),.receipt.svelte-1j425e6 li:where(.svelte-1j425e6){margin:.25rem 0 0;color:var(--color-text);font-size:.76rem;line-height:1.45;overflow-wrap:anywhere}.receipt.svelte-1j425e6 ul:where(.svelte-1j425e6){margin:.25rem 0 0;padding-left:1rem}.appeal-row.svelte-1j425e6{display:flex;align-items:center;gap:.4rem;margin-top:.85rem;flex-wrap:wrap}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6),.appeal-row.svelte-1j425e6 p:where(.svelte-1j425e6){border:1px solid rgba(255,255,255,.1);border-radius:.4rem;padding:.35rem .6rem;color:var(--color-text);background:#ffffff0a;font-size:.72rem;margin:0}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6):hover:not(:disabled),.verdict-summary.svelte-1j425e6:hover{background:#ffffff0d}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6):disabled{opacity:.55;cursor:wait}.tone-pass.svelte-1j425e6,.tone-note.svelte-1j425e6{--verdict-color: #10b981}.tone-caution.svelte-1j425e6{--verdict-color: #f59e0b}.tone-veto.svelte-1j425e6{--verdict-color: #ef4444}.tone-appealed.svelte-1j425e6{--verdict-color: #818cf8}@media(max-width:900px){.verdict-summary.svelte-1j425e6{grid-template-columns:auto minmax(0,1fr) auto}.levels.svelte-1j425e6{grid-column:1 / -1;order:4;overflow-x:auto;padding-bottom:.1rem}.receipt-grid.svelte-1j425e6{grid-template-columns:1fr}}.theme-toggle.svelte-1cmi4dh{width:30px;height:30px;display:inline-flex;align-items:center;justify-content:center;padding:0;border-radius:8px;background:#6366f10f;border:1px solid rgba(99,102,241,.14);color:var(--color-text);cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease,transform .12s ease;-webkit-tap-highlight-color:transparent}.theme-toggle.svelte-1cmi4dh:hover{background:#6366f124;border-color:#6366f14d;color:var(--color-bright)}.theme-toggle.svelte-1cmi4dh:active{transform:scale(.94)}.theme-toggle.svelte-1cmi4dh:focus-visible{outline:1px solid var(--color-synapse);outline-offset:2px}.icon-wrap.svelte-1cmi4dh{position:relative;width:18px;height:18px;display:inline-block}.icon.svelte-1cmi4dh{position:absolute;top:0;right:0;bottom:0;left:0;width:18px;height:18px;opacity:0;transform:scale(.7) rotate(-30deg);transition:opacity .2s ease,transform .2s cubic-bezier(.16,1,.3,1);pointer-events:none}.icon.active.svelte-1cmi4dh{opacity:1;transform:scale(1) rotate(0)}.theme-toggle[data-mode=dark].svelte-1cmi4dh{color:var(--color-synapse-glow, #818cf8)}.theme-toggle[data-mode=light].svelte-1cmi4dh{color:var(--color-warning, #f59e0b)}.theme-toggle[data-mode=auto].svelte-1cmi4dh{color:var(--color-dream-glow, #c084fc)}@media(prefers-reduced-motion:reduce){.theme-toggle.svelte-1cmi4dh,.icon.svelte-1cmi4dh{transition:none}}.safe-bottom.svelte-12qhfyh{padding-bottom:env(safe-area-inset-bottom,0px)}@keyframes svelte-12qhfyh-page-in{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}.animate-page-in.svelte-12qhfyh{animation:svelte-12qhfyh-page-in .2s ease-out} +/*! tailwindcss v4.2.0 | MIT License | https://tailwindcss.com */@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-scale-x:1;--tw-scale-y:1;--tw-scale-z:1;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-border-style:solid;--tw-gradient-position:initial;--tw-gradient-from:#0000;--tw-gradient-via:#0000;--tw-gradient-to:#0000;--tw-gradient-stops:initial;--tw-gradient-via-stops:initial;--tw-gradient-from-position:0%;--tw-gradient-via-position:50%;--tw-gradient-to-position:100%;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-backdrop-blur:initial;--tw-backdrop-brightness:initial;--tw-backdrop-contrast:initial;--tw-backdrop-grayscale:initial;--tw-backdrop-hue-rotate:initial;--tw-backdrop-invert:initial;--tw-backdrop-opacity:initial;--tw-backdrop-saturate:initial;--tw-backdrop-sepia:initial;--tw-duration:initial;--tw-ease:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";--font-mono:"JetBrains Mono", "Fira Code", "SF Mono", monospace;--color-amber-400:oklch(82.8% .189 84.429);--color-purple-400:oklch(71.4% .203 305.504);--color-purple-500:oklch(62.7% .265 303.9);--color-black:#000;--color-white:#fff;--spacing:.25rem;--container-xs:20rem;--container-md:28rem;--container-lg:32rem;--container-xl:36rem;--container-2xl:42rem;--container-4xl:56rem;--container-5xl:64rem;--container-6xl:72rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height: 1.5 ;--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--text-3xl:1.875rem;--text-3xl--line-height: 1.2 ;--text-4xl:2.25rem;--text-4xl--line-height:calc(2.5 / 2.25);--text-5xl:3rem;--text-5xl--line-height:1;--text-6xl:3.75rem;--text-6xl--line-height:1;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--font-weight-bold:700;--tracking-tight:-.025em;--tracking-wide:.025em;--tracking-wider:.05em;--tracking-widest:.1em;--leading-snug:1.375;--leading-relaxed:1.625;--radius-sm:.25rem;--radius-md:.375rem;--radius-lg:.5rem;--radius-xl:.75rem;--radius-2xl:1rem;--ease-out:cubic-bezier(0, 0, .2, 1);--ease-in-out:cubic-bezier(.4, 0, .2, 1);--animate-spin:spin 1s linear infinite;--animate-ping:ping 1s cubic-bezier(0, 0, .2, 1) infinite;--animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--blur-sm:8px;--blur-md:12px;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:var(--font-sans);--default-mono-font-family:var(--font-mono);--color-void:#050510;--color-abyss:#0a0a1a;--color-deep:#10102a;--color-surface:#161638;--color-elevated:#1e1e4a;--color-subtle:#2a2a5e;--color-muted:#4a4a7a;--color-dim:#7a7aaa;--color-text:#e0e0ff;--color-bright:#fff;--color-synapse:#6366f1;--color-synapse-glow:#818cf8;--color-dream:#a855f7;--color-dream-glow:#c084fc;--color-memory:#3b82f6;--color-recall:#10b981;--color-decay:#ef4444;--color-warning:#f59e0b;--color-node-pattern:#ec4899}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;-moz-tab-size:4;tab-size:4;line-height:1.5;font-family:var(--default-font-family,ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring{outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab,red,red)){::placeholder{color:color-mix(in oklab,currentcolor 50%,transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){-webkit-appearance:button;-moz-appearance:button;appearance:button}::file-selector-button{-webkit-appearance:button;-moz-appearance:button;appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}}@layer components;@layer utilities{.pointer-events-auto{pointer-events:auto}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.sticky{position:sticky}.inset-0{inset:calc(var(--spacing) * 0)}.inset-x-0{inset-inline:calc(var(--spacing) * 0)}.start{inset-inline-start:var(--spacing)}.end{inset-inline-end:var(--spacing)}.end\!{inset-inline-end:var(--spacing)!important}.top-0{top:calc(var(--spacing) * 0)}.top-0\.5{top:calc(var(--spacing) * .5)}.top-1{top:calc(var(--spacing) * 1)}.top-3{top:calc(var(--spacing) * 3)}.top-4{top:calc(var(--spacing) * 4)}.top-10{top:calc(var(--spacing) * 10)}.right-0{right:calc(var(--spacing) * 0)}.right-4{right:calc(var(--spacing) * 4)}.bottom-0{bottom:calc(var(--spacing) * 0)}.bottom-4{bottom:calc(var(--spacing) * 4)}.-left-\[29px\]{left:-29px}.left-1\/2{left:50%}.left-4{left:calc(var(--spacing) * 4)}.left-6{left:calc(var(--spacing) * 6)}.isolate{isolation:isolate}.z-10{z-index:10}.z-20{z-index:20}.z-40{z-index:40}.z-50{z-index:50}.z-\[1\]{z-index:1}.container{width:100%}@media(min-width:40rem){.container{max-width:40rem}}@media(min-width:48rem){.container{max-width:48rem}}@media(min-width:64rem){.container{max-width:64rem}}@media(min-width:80rem){.container{max-width:80rem}}@media(min-width:96rem){.container{max-width:96rem}}.mx-2{margin-inline:calc(var(--spacing) * 2)}.mx-auto{margin-inline:auto}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:calc(var(--spacing) * 1)}.mt-1\.5{margin-top:calc(var(--spacing) * 1.5)}.mt-2{margin-top:calc(var(--spacing) * 2)}.mt-3{margin-top:calc(var(--spacing) * 3)}.mt-4{margin-top:calc(var(--spacing) * 4)}.mt-\[-12px\]{margin-top:-12px}.mr-1{margin-right:calc(var(--spacing) * 1)}.mr-2{margin-right:calc(var(--spacing) * 2)}.mb-0\.5{margin-bottom:calc(var(--spacing) * .5)}.mb-1{margin-bottom:calc(var(--spacing) * 1)}.mb-1\.5{margin-bottom:calc(var(--spacing) * 1.5)}.mb-2{margin-bottom:calc(var(--spacing) * 2)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.mb-4{margin-bottom:calc(var(--spacing) * 4)}.ml-2{margin-left:calc(var(--spacing) * 2)}.ml-3{margin-left:calc(var(--spacing) * 3)}.ml-auto{margin-left:auto}.line-clamp-1{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-2{-webkit-line-clamp:2;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-3{-webkit-line-clamp:3;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.line-clamp-4{-webkit-line-clamp:4;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}.block{display:block}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-flex{display:inline-flex}.table{display:table}.aspect-square{aspect-ratio:1}.h-0\.5{height:calc(var(--spacing) * .5)}.h-1{height:calc(var(--spacing) * 1)}.h-1\.5{height:calc(var(--spacing) * 1.5)}.h-2{height:calc(var(--spacing) * 2)}.h-2\.5{height:calc(var(--spacing) * 2.5)}.h-3{height:calc(var(--spacing) * 3)}.h-4{height:calc(var(--spacing) * 4)}.h-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-12{height:calc(var(--spacing) * 12)}.h-14{height:calc(var(--spacing) * 14)}.h-16{height:calc(var(--spacing) * 16)}.h-20{height:calc(var(--spacing) * 20)}.h-24{height:calc(var(--spacing) * 24)}.h-28{height:calc(var(--spacing) * 28)}.h-32{height:calc(var(--spacing) * 32)}.h-40{height:calc(var(--spacing) * 40)}.h-\[520px\]{height:520px}.h-\[560px\]{height:560px}.h-full{height:100%}.h-px{height:1px}.h-screen{height:100vh}.max-h-48{max-height:calc(var(--spacing) * 48)}.max-h-64{max-height:calc(var(--spacing) * 64)}.max-h-72{max-height:calc(var(--spacing) * 72)}.max-h-96{max-height:calc(var(--spacing) * 96)}.max-h-\[620px\]{max-height:620px}.min-h-0{min-height:calc(var(--spacing) * 0)}.min-h-40{min-height:calc(var(--spacing) * 40)}.min-h-\[240px\]{min-height:240px}.min-h-\[320px\]{min-height:320px}.min-h-\[520px\]{min-height:520px}.min-h-full{min-height:100%}.w-1\.5{width:calc(var(--spacing) * 1.5)}.w-2{width:calc(var(--spacing) * 2)}.w-2\.5{width:calc(var(--spacing) * 2.5)}.w-3{width:calc(var(--spacing) * 3)}.w-4{width:calc(var(--spacing) * 4)}.w-5{width:calc(var(--spacing) * 5)}.w-6{width:calc(var(--spacing) * 6)}.w-7{width:calc(var(--spacing) * 7)}.w-8{width:calc(var(--spacing) * 8)}.w-9{width:calc(var(--spacing) * 9)}.w-12{width:calc(var(--spacing) * 12)}.w-14{width:calc(var(--spacing) * 14)}.w-16{width:calc(var(--spacing) * 16)}.w-20{width:calc(var(--spacing) * 20)}.w-24{width:calc(var(--spacing) * 24)}.w-32{width:calc(var(--spacing) * 32)}.w-96{width:calc(var(--spacing) * 96)}.w-\[3px\]{width:3px}.w-\[90\%\]{width:90%}.w-full{width:100%}.w-px{width:1px}.max-w-2xl{max-width:var(--container-2xl)}.max-w-4xl{max-width:var(--container-4xl)}.max-w-5xl{max-width:var(--container-5xl)}.max-w-6xl{max-width:var(--container-6xl)}.max-w-7xl{max-width:var(--container-7xl)}.max-w-20{max-width:calc(var(--spacing) * 20)}.max-w-\[220px\]{max-width:220px}.max-w-lg{max-width:var(--container-lg)}.max-w-md{max-width:var(--container-md)}.max-w-xl{max-width:var(--container-xl)}.max-w-xs{max-width:var(--container-xs)}.min-w-0{min-width:calc(var(--spacing) * 0)}.min-w-12{min-width:calc(var(--spacing) * 12)}.min-w-16{min-width:calc(var(--spacing) * 16)}.min-w-64{min-width:calc(var(--spacing) * 64)}.min-w-\[2rem\]{min-width:2rem}.min-w-\[3\.5rem\]{min-width:3.5rem}.flex-1{flex:1}.flex-shrink{flex-shrink:1}.flex-shrink-0{flex-shrink:0}.shrink{flex-shrink:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.border-separate{border-collapse:separate}.-translate-x-1\/2{--tw-translate-x: -50% ;translate:var(--tw-translate-x) var(--tw-translate-y)}.scale-125{--tw-scale-x:125%;--tw-scale-y:125%;--tw-scale-z:125%;scale:var(--tw-scale-x) var(--tw-scale-y)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.animate-\[fadeSlide_0\.35s_ease-out_both\]{animation:.35s ease-out both fadeSlide}.animate-ping{animation:var(--animate-ping)}.animate-pulse{animation:var(--animate-pulse)}.animate-spin{animation:var(--animate-spin)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.resize{resize:both}.resize-none{resize:none}.resize-y{resize:vertical}.appearance-none{-webkit-appearance:none;-moz-appearance:none;appearance:none}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.grid-cols-7{grid-template-columns:repeat(7,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-baseline{align-items:baseline}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-around{justify-content:space-around}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.gap-0{gap:calc(var(--spacing) * 0)}.gap-0\.5{gap:calc(var(--spacing) * .5)}.gap-1{gap:calc(var(--spacing) * 1)}.gap-1\.5{gap:calc(var(--spacing) * 1.5)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}.gap-4{gap:calc(var(--spacing) * 4)}.gap-5{gap:calc(var(--spacing) * 5)}.gap-6{gap:calc(var(--spacing) * 6)}.gap-\[2px\]{gap:2px}:where(.space-y-0\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * .5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * .5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-1\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 1.5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 1.5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-2>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 2) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 2) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-4>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 4) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 4) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 5) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 6) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-8>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 8) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 8) * calc(1 - var(--tw-space-y-reverse)))}.gap-x-6{column-gap:calc(var(--spacing) * 6)}.gap-y-1{row-gap:calc(var(--spacing) * 1)}.self-center{align-self:center}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-2xl{border-radius:var(--radius-2xl)}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius-lg)}.rounded-md{border-radius:var(--radius-md)}.rounded-sm{border-radius:var(--radius-sm)}.rounded-xl{border-radius:var(--radius-xl)}.rounded-t{border-top-left-radius:.25rem;border-top-right-radius:.25rem}.border{border-style:var(--tw-border-style);border-width:1px}.border-2{border-style:var(--tw-border-style);border-width:2px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-l{border-left-style:var(--tw-border-style);border-left-width:1px}.\!border-decay\/20{border-color:#ef444433!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)!important}}.\!border-decay\/30{border-color:#ef44444d!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/30{border-color:color-mix(in oklab,var(--color-decay) 30%,transparent)!important}}.\!border-decay\/40{border-color:#ef444466!important}@supports (color:color-mix(in lab,red,red)){.\!border-decay\/40{border-color:color-mix(in oklab,var(--color-decay) 40%,transparent)!important}}.\!border-dream\/20{border-color:#a855f733!important}@supports (color:color-mix(in lab,red,red)){.\!border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)!important}}.\!border-synapse\/15{border-color:#6366f126!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)!important}}.\!border-synapse\/20{border-color:#6366f133!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)!important}}.\!border-synapse\/25{border-color:#6366f140!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/25{border-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)!important}}.\!border-synapse\/30{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.\!border-synapse\/40{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.\!border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.border-\[\#A33FFF\]\/40{border-color:#a33fff66}.border-decay\/20{border-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.border-decay\/20{border-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.border-dream-glow\/40{border-color:#c084fc66}@supports (color:color-mix(in lab,red,red)){.border-dream-glow\/40{border-color:color-mix(in oklab,var(--color-dream-glow) 40%,transparent)}}.border-dream\/10{border-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.border-dream\/10{border-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.border-dream\/20{border-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.border-dream\/20{border-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.border-dream\/30{border-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.border-dream\/30{border-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.border-dream\/40{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.border-dream\/40{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.border-dream\/50{border-color:#a855f780}@supports (color:color-mix(in lab,red,red)){.border-dream\/50{border-color:color-mix(in oklab,var(--color-dream) 50%,transparent)}}.border-recall\/30{border-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.border-recall\/30{border-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.border-recall\/40{border-color:#10b98166}@supports (color:color-mix(in lab,red,red)){.border-recall\/40{border-color:color-mix(in oklab,var(--color-recall) 40%,transparent)}}.border-subtle\/15{border-color:#2a2a5e26}@supports (color:color-mix(in lab,red,red)){.border-subtle\/15{border-color:color-mix(in oklab,var(--color-subtle) 15%,transparent)}}.border-subtle\/20{border-color:#2a2a5e33}@supports (color:color-mix(in lab,red,red)){.border-subtle\/20{border-color:color-mix(in oklab,var(--color-subtle) 20%,transparent)}}.border-subtle\/30{border-color:#2a2a5e4d}@supports (color:color-mix(in lab,red,red)){.border-subtle\/30{border-color:color-mix(in oklab,var(--color-subtle) 30%,transparent)}}.border-synapse{border-color:var(--color-synapse)}.border-synapse\/5{border-color:#6366f10d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/5{border-color:color-mix(in oklab,var(--color-synapse) 5%,transparent)}}.border-synapse\/10{border-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.border-synapse\/10{border-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.border-synapse\/15{border-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.border-synapse\/15{border-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.border-synapse\/20{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.border-synapse\/20{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.border-synapse\/30{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.border-synapse\/30{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.border-synapse\/40{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.border-synapse\/40{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.border-transparent{border-color:#0000}.border-warning\/30{border-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.border-warning\/30{border-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.border-warning\/40{border-color:#f59e0b66}@supports (color:color-mix(in lab,red,red)){.border-warning\/40{border-color:color-mix(in oklab,var(--color-warning) 40%,transparent)}}.border-warning\/50{border-color:#f59e0b80}@supports (color:color-mix(in lab,red,red)){.border-warning\/50{border-color:color-mix(in oklab,var(--color-warning) 50%,transparent)}}.border-white\/5{border-color:#ffffff0d}@supports (color:color-mix(in lab,red,red)){.border-white\/5{border-color:color-mix(in oklab,var(--color-white) 5%,transparent)}}.border-t-dream{border-top-color:var(--color-dream)}.border-t-synapse{border-top-color:var(--color-synapse)}.border-t-warning{border-top-color:var(--color-warning)}.bg-\[\#A33FFF\]{background-color:#a33fff}.bg-\[\#A33FFF\]\/10{background-color:#a33fff1a}.bg-amber-400{background-color:var(--color-amber-400)}.bg-black\/40{background-color:#0006}@supports (color:color-mix(in lab,red,red)){.bg-black\/40{background-color:color-mix(in oklab,var(--color-black) 40%,transparent)}}.bg-decay{background-color:var(--color-decay)}.bg-decay\/10{background-color:#ef44441a}@supports (color:color-mix(in lab,red,red)){.bg-decay\/10{background-color:color-mix(in oklab,var(--color-decay) 10%,transparent)}}.bg-decay\/20{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.bg-decay\/20{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.bg-decay\/\[0\.05\]{background-color:#ef44440d}@supports (color:color-mix(in lab,red,red)){.bg-decay\/\[0\.05\]{background-color:color-mix(in oklab,var(--color-decay) 5%,transparent)}}.bg-deep{background-color:var(--color-deep)}.bg-deep\/40{background-color:#10102a66}@supports (color:color-mix(in lab,red,red)){.bg-deep\/40{background-color:color-mix(in oklab,var(--color-deep) 40%,transparent)}}.bg-deep\/60{background-color:#10102a99}@supports (color:color-mix(in lab,red,red)){.bg-deep\/60{background-color:color-mix(in oklab,var(--color-deep) 60%,transparent)}}.bg-dream{background-color:var(--color-dream)}.bg-dream\/5{background-color:#a855f70d}@supports (color:color-mix(in lab,red,red)){.bg-dream\/5{background-color:color-mix(in oklab,var(--color-dream) 5%,transparent)}}.bg-dream\/10{background-color:#a855f71a}@supports (color:color-mix(in lab,red,red)){.bg-dream\/10{background-color:color-mix(in oklab,var(--color-dream) 10%,transparent)}}.bg-dream\/15{background-color:#a855f726}@supports (color:color-mix(in lab,red,red)){.bg-dream\/15{background-color:color-mix(in oklab,var(--color-dream) 15%,transparent)}}.bg-dream\/20{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.bg-dream\/20{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.bg-muted{background-color:var(--color-muted)}.bg-node-pattern{background-color:var(--color-node-pattern)}.bg-purple-500\/20{background-color:#ac4bff33}@supports (color:color-mix(in lab,red,red)){.bg-purple-500\/20{background-color:color-mix(in oklab,var(--color-purple-500) 20%,transparent)}}.bg-recall{background-color:var(--color-recall)}.bg-recall\/10{background-color:#10b9811a}@supports (color:color-mix(in lab,red,red)){.bg-recall\/10{background-color:color-mix(in oklab,var(--color-recall) 10%,transparent)}}.bg-recall\/15{background-color:#10b98126}@supports (color:color-mix(in lab,red,red)){.bg-recall\/15{background-color:color-mix(in oklab,var(--color-recall) 15%,transparent)}}.bg-recall\/20{background-color:#10b98133}@supports (color:color-mix(in lab,red,red)){.bg-recall\/20{background-color:color-mix(in oklab,var(--color-recall) 20%,transparent)}}.bg-synapse{background-color:var(--color-synapse)}.bg-synapse-glow{background-color:var(--color-synapse-glow)}.bg-synapse\/10{background-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/10{background-color:color-mix(in oklab,var(--color-synapse) 10%,transparent)}}.bg-synapse\/15{background-color:#6366f126}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/15{background-color:color-mix(in oklab,var(--color-synapse) 15%,transparent)}}.bg-synapse\/20{background-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/20{background-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.bg-synapse\/25{background-color:#6366f140}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/25{background-color:color-mix(in oklab,var(--color-synapse) 25%,transparent)}}.bg-synapse\/70{background-color:#6366f1b3}@supports (color:color-mix(in lab,red,red)){.bg-synapse\/70{background-color:color-mix(in oklab,var(--color-synapse) 70%,transparent)}}.bg-transparent{background-color:#0000}.bg-void{background-color:var(--color-void)}.bg-void\/60{background-color:#05051099}@supports (color:color-mix(in lab,red,red)){.bg-void\/60{background-color:color-mix(in oklab,var(--color-void) 60%,transparent)}}.bg-warning{background-color:var(--color-warning)}.bg-warning\/5{background-color:#f59e0b0d}@supports (color:color-mix(in lab,red,red)){.bg-warning\/5{background-color:color-mix(in oklab,var(--color-warning) 5%,transparent)}}.bg-warning\/20{background-color:#f59e0b33}@supports (color:color-mix(in lab,red,red)){.bg-warning\/20{background-color:color-mix(in oklab,var(--color-warning) 20%,transparent)}}.bg-white\/\[0\.02\]{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.02\]{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.bg-white\/\[0\.03\]{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.03\]{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.bg-white\/\[0\.04\]{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.04\]{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.bg-white\/\[0\.06\]{background-color:#ffffff0f}@supports (color:color-mix(in lab,red,red)){.bg-white\/\[0\.06\]{background-color:color-mix(in oklab,var(--color-white) 6%,transparent)}}.bg-gradient-to-br{--tw-gradient-position:to bottom right in oklab;background-image:linear-gradient(var(--tw-gradient-stops))}.from-dream{--tw-gradient-from:var(--color-dream);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.to-synapse{--tw-gradient-to:var(--color-synapse);--tw-gradient-stops:var(--tw-gradient-via-stops,var(--tw-gradient-position), var(--tw-gradient-from) var(--tw-gradient-from-position), var(--tw-gradient-to) var(--tw-gradient-to-position))}.p-0{padding:calc(var(--spacing) * 0)}.p-0\.5{padding:calc(var(--spacing) * .5)}.p-1{padding:calc(var(--spacing) * 1)}.p-2{padding:calc(var(--spacing) * 2)}.p-2\.5{padding:calc(var(--spacing) * 2.5)}.p-3{padding:calc(var(--spacing) * 3)}.p-4{padding:calc(var(--spacing) * 4)}.p-5{padding:calc(var(--spacing) * 5)}.p-6{padding:calc(var(--spacing) * 6)}.p-10{padding:calc(var(--spacing) * 10)}.p-12{padding:calc(var(--spacing) * 12)}.px-1{padding-inline:calc(var(--spacing) * 1)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-2\.5{padding-inline:calc(var(--spacing) * 2.5)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.px-5{padding-inline:calc(var(--spacing) * 5)}.px-6{padding-inline:calc(var(--spacing) * 6)}.px-8{padding-inline:calc(var(--spacing) * 8)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1{padding-block:calc(var(--spacing) * 1)}.py-1\.5{padding-block:calc(var(--spacing) * 1.5)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-3{padding-block:calc(var(--spacing) * 3)}.py-4{padding-block:calc(var(--spacing) * 4)}.py-5{padding-block:calc(var(--spacing) * 5)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.py-10{padding-block:calc(var(--spacing) * 10)}.py-12{padding-block:calc(var(--spacing) * 12)}.py-20{padding-block:calc(var(--spacing) * 20)}.pt-1{padding-top:calc(var(--spacing) * 1)}.pt-2{padding-top:calc(var(--spacing) * 2)}.pt-3{padding-top:calc(var(--spacing) * 3)}.pt-4{padding-top:calc(var(--spacing) * 4)}.pt-6{padding-top:calc(var(--spacing) * 6)}.pt-8{padding-top:calc(var(--spacing) * 8)}.pt-\[10vh\]{padding-top:10vh}.pr-1{padding-right:calc(var(--spacing) * 1)}.pr-2{padding-right:calc(var(--spacing) * 2)}.pb-2{padding-bottom:calc(var(--spacing) * 2)}.pb-16{padding-bottom:calc(var(--spacing) * 16)}.pl-6{padding-left:calc(var(--spacing) * 6)}.pl-14{padding-left:calc(var(--spacing) * 14)}.text-center{text-align:center}.text-left{text-align:left}.text-right{text-align:right}.align-bottom{vertical-align:bottom}.align-top{vertical-align:top}.font-mono{font-family:var(--font-mono)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-3xl{font-size:var(--text-3xl);line-height:var(--tw-leading,var(--text-3xl--line-height))}.text-4xl{font-size:var(--text-4xl);line-height:var(--tw-leading,var(--text-4xl--line-height))}.text-5xl{font-size:var(--text-5xl);line-height:var(--tw-leading,var(--text-5xl--line-height))}.text-6xl{font-size:var(--text-6xl);line-height:var(--tw-leading,var(--text-6xl--line-height))}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[8px\]{font-size:8px}.text-\[9px\]{font-size:9px}.text-\[10px\]{font-size:10px}.text-\[11px\]{font-size:11px}.leading-none{--tw-leading:1;line-height:1}.leading-relaxed{--tw-leading:var(--leading-relaxed);line-height:var(--leading-relaxed)}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.font-bold{--tw-font-weight:var(--font-weight-bold);font-weight:var(--font-weight-bold)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-\[0\.12em\]{--tw-tracking:.12em;letter-spacing:.12em}.tracking-\[0\.15em\]{--tw-tracking:.15em;letter-spacing:.15em}.tracking-\[0\.18em\]{--tw-tracking:.18em;letter-spacing:.18em}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.tracking-wide{--tw-tracking:var(--tracking-wide);letter-spacing:var(--tracking-wide)}.tracking-wider{--tw-tracking:var(--tracking-wider);letter-spacing:var(--tracking-wider)}.tracking-widest{--tw-tracking:var(--tracking-widest);letter-spacing:var(--tracking-widest)}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.whitespace-pre-wrap{white-space:pre-wrap}.text-\[\#E4C8FF\]{color:#e4c8ff}.text-amber-400{color:var(--color-amber-400)}.text-bright{color:var(--color-bright)}.text-decay{color:var(--color-decay)}.text-decay\/60{color:#ef444499}@supports (color:color-mix(in lab,red,red)){.text-decay\/60{color:color-mix(in oklab,var(--color-decay) 60%,transparent)}}.text-dim{color:var(--color-dim)}.text-dream{color:var(--color-dream)}.text-dream-glow{color:var(--color-dream-glow)}.text-dream\/40{color:#a855f766}@supports (color:color-mix(in lab,red,red)){.text-dream\/40{color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.text-dream\/80{color:#a855f7cc}@supports (color:color-mix(in lab,red,red)){.text-dream\/80{color:color-mix(in oklab,var(--color-dream) 80%,transparent)}}.text-memory{color:var(--color-memory)}.text-muted{color:var(--color-muted)}.text-muted\/50{color:#4a4a7a80}@supports (color:color-mix(in lab,red,red)){.text-muted\/50{color:color-mix(in oklab,var(--color-muted) 50%,transparent)}}.text-muted\/60{color:#4a4a7a99}@supports (color:color-mix(in lab,red,red)){.text-muted\/60{color:color-mix(in oklab,var(--color-muted) 60%,transparent)}}.text-node-pattern{color:var(--color-node-pattern)}.text-purple-400{color:var(--color-purple-400)}.text-recall{color:var(--color-recall)}.text-subtle{color:var(--color-subtle)}.text-synapse{color:var(--color-synapse)}.text-synapse-glow{color:var(--color-synapse-glow)}.text-text{color:var(--color-text)}.text-text\/80{color:#e0e0ffcc}@supports (color:color-mix(in lab,red,red)){.text-text\/80{color:color-mix(in oklab,var(--color-text) 80%,transparent)}}.text-warning{color:var(--color-warning)}.capitalize{text-transform:capitalize}.uppercase{text-transform:uppercase}.italic{font-style:italic}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.underline-offset-4{text-underline-offset:4px}.accent-synapse{accent-color:var(--color-synapse)}.accent-synapse-glow{accent-color:var(--color-synapse-glow)}.opacity-20{opacity:.2}.opacity-30{opacity:.3}.opacity-35{opacity:.35}.opacity-40{opacity:.4}.opacity-60{opacity:.6}.opacity-75{opacity:.75}.opacity-100{opacity:1}.shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow\!{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a)!important;box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)!important}.shadow-2xl{--tw-shadow:0 25px 50px -12px var(--tw-shadow-color,#00000040);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_10px_rgba\(239\,68\,68\,0\.7\)\]{--tw-shadow:0 0 10px var(--tw-shadow-color,#ef4444b3);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f126);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(99\,102\,241\,0\.18\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#6366f12e);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_12px_rgba\(163\,63\,255\,0\.15\)\]{--tw-shadow:0 0 12px var(--tw-shadow-color,#a33fff26);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(99\,102\,241\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#6366f14d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-\[0_0_16px_rgba\(168\,85\,247\,0\.3\)\]{--tw-shadow:0 0 16px var(--tw-shadow-color,#a855f74d);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-xl{--tw-shadow:0 20px 25px -5px var(--tw-shadow-color,#0000001a), 0 8px 10px -6px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring,.ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.ring-2{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.shadow-synapse\/10{--tw-shadow-color:#6366f11a}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/10{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 10%, transparent) var(--tw-shadow-alpha), transparent)}}.shadow-synapse\/20{--tw-shadow-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.shadow-synapse\/20{--tw-shadow-color:color-mix(in oklab, color-mix(in oklab, var(--color-synapse) 20%, transparent) var(--tw-shadow-alpha), transparent)}}.ring-dream-glow{--tw-ring-color:var(--color-dream-glow)}.ring-dream\/60{--tw-ring-color:#a855f799}@supports (color:color-mix(in lab,red,red)){.ring-dream\/60{--tw-ring-color:color-mix(in oklab, var(--color-dream) 60%, transparent)}}.ring-recall\/30{--tw-ring-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.ring-recall\/30{--tw-ring-color:color-mix(in oklab, var(--color-recall) 30%, transparent)}}.ring-synapse\/60{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.ring-synapse\/60{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.blur{--tw-blur:blur(8px);filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.backdrop-blur-md{--tw-backdrop-blur:blur(var(--blur-md));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-blur-sm{--tw-backdrop-blur:blur(var(--blur-sm));-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.backdrop-filter{-webkit-backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,);backdrop-filter:var(--tw-backdrop-blur,) var(--tw-backdrop-brightness,) var(--tw-backdrop-contrast,) var(--tw-backdrop-grayscale,) var(--tw-backdrop-hue-rotate,) var(--tw-backdrop-invert,) var(--tw-backdrop-opacity,) var(--tw-backdrop-saturate,) var(--tw-backdrop-sepia,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-transform{transition-property:transform,translate,scale,rotate;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-200{--tw-duration:.2s;transition-duration:.2s}.duration-300{--tw-duration:.3s;transition-duration:.3s}.duration-500{--tw-duration:.5s;transition-duration:.5s}.duration-700{--tw-duration:.7s;transition-duration:.7s}.ease-in-out{--tw-ease:var(--ease-in-out);transition-timing-function:var(--ease-in-out)}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}.select-none{-webkit-user-select:none;user-select:none}.placeholder\:text-muted::placeholder{color:var(--color-muted)}@media(hover:hover){.hover\:z-10:hover{z-index:10}.hover\:scale-110:hover{--tw-scale-x:110%;--tw-scale-y:110%;--tw-scale-z:110%;scale:var(--tw-scale-x) var(--tw-scale-y)}.hover\:scale-\[1\.03\]:hover{scale:1.03}.hover\:\!border-synapse\/30:hover{border-color:#6366f14d!important}@supports (color:color-mix(in lab,red,red)){.hover\:\!border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)!important}}.hover\:border-synapse\/20:hover{border-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/20:hover{border-color:color-mix(in oklab,var(--color-synapse) 20%,transparent)}}.hover\:border-synapse\/30:hover{border-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/30:hover{border-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:border-synapse\/50:hover{border-color:#6366f180}@supports (color:color-mix(in lab,red,red)){.hover\:border-synapse\/50:hover{border-color:color-mix(in oklab,var(--color-synapse) 50%,transparent)}}.hover\:bg-decay\/20:hover{background-color:#ef444433}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/20:hover{background-color:color-mix(in oklab,var(--color-decay) 20%,transparent)}}.hover\:bg-decay\/30:hover{background-color:#ef44444d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-decay\/30:hover{background-color:color-mix(in oklab,var(--color-decay) 30%,transparent)}}.hover\:bg-dream\/20:hover{background-color:#a855f733}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/20:hover{background-color:color-mix(in oklab,var(--color-dream) 20%,transparent)}}.hover\:bg-dream\/30:hover{background-color:#a855f74d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-dream\/30:hover{background-color:color-mix(in oklab,var(--color-dream) 30%,transparent)}}.hover\:bg-purple-500\/30:hover{background-color:#ac4bff4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-purple-500\/30:hover{background-color:color-mix(in oklab,var(--color-purple-500) 30%,transparent)}}.hover\:bg-recall\/30:hover{background-color:#10b9814d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-recall\/30:hover{background-color:color-mix(in oklab,var(--color-recall) 30%,transparent)}}.hover\:bg-synapse\/30:hover{background-color:#6366f14d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-synapse\/30:hover{background-color:color-mix(in oklab,var(--color-synapse) 30%,transparent)}}.hover\:bg-warning\/30:hover{background-color:#f59e0b4d}@supports (color:color-mix(in lab,red,red)){.hover\:bg-warning\/30:hover{background-color:color-mix(in oklab,var(--color-warning) 30%,transparent)}}.hover\:bg-white\/\[0\.02\]:hover{background-color:#ffffff05}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.02\]:hover{background-color:color-mix(in oklab,var(--color-white) 2%,transparent)}}.hover\:bg-white\/\[0\.03\]:hover{background-color:#ffffff08}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.03\]:hover{background-color:color-mix(in oklab,var(--color-white) 3%,transparent)}}.hover\:bg-white\/\[0\.04\]:hover{background-color:#ffffff0a}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.04\]:hover{background-color:color-mix(in oklab,var(--color-white) 4%,transparent)}}.hover\:bg-white\/\[0\.08\]:hover{background-color:#ffffff14}@supports (color:color-mix(in lab,red,red)){.hover\:bg-white\/\[0\.08\]:hover{background-color:color-mix(in oklab,var(--color-white) 8%,transparent)}}.hover\:text-bright:hover{color:var(--color-bright)}.hover\:text-dim:hover{color:var(--color-dim)}.hover\:text-synapse-glow:hover{color:var(--color-synapse-glow)}.hover\:text-text:hover{color:var(--color-text)}.hover\:underline:hover{text-decoration-line:underline}}.focus\:\!border-synapse\/40:focus{border-color:#6366f166!important}@supports (color:color-mix(in lab,red,red)){.focus\:\!border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)!important}}.focus\:border-dream\/40:focus{border-color:#a855f766}@supports (color:color-mix(in lab,red,red)){.focus\:border-dream\/40:focus{border-color:color-mix(in oklab,var(--color-dream) 40%,transparent)}}.focus\:border-synapse\/40:focus{border-color:#6366f166}@supports (color:color-mix(in lab,red,red)){.focus\:border-synapse\/40:focus{border-color:color-mix(in oklab,var(--color-synapse) 40%,transparent)}}.focus\:ring-1:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus\:ring-synapse-glow:focus{--tw-ring-color:var(--color-synapse-glow)}.focus\:ring-synapse\/20:focus{--tw-ring-color:#6366f133}@supports (color:color-mix(in lab,red,red)){.focus\:ring-synapse\/20:focus{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 20%, transparent)}}.focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.focus-visible\:ring-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:#c084fc99}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-dream-glow\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-dream-glow) 60%, transparent)}}.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:#10b98199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-recall\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-recall) 60%, transparent)}}.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:#6366f199}@supports (color:color-mix(in lab,red,red)){.focus-visible\:ring-synapse\/60:focus-visible{--tw-ring-color:color-mix(in oklab, var(--color-synapse) 60%, transparent)}}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:opacity-40:disabled{opacity:.4}.disabled\:opacity-50:disabled{opacity:.5}@media(min-width:40rem){.sm\:block{display:block}.sm\:inline-flex{display:inline-flex}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}}@media(min-width:48rem){.md\:block{display:block}.md\:flex{display:flex}.md\:hidden{display:none}.md\:inline-flex{display:inline-flex}.md\:min-w-\[340px\]{min-width:340px}.md\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.md\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.md\:grid-cols-5{grid-template-columns:repeat(5,minmax(0,1fr))}.md\:grid-cols-\[1fr_auto\]{grid-template-columns:1fr auto}.md\:grid-cols-\[280px_1fr\]{grid-template-columns:280px 1fr}.md\:flex-row{flex-direction:row}.md\:pt-\[15vh\]{padding-top:15vh}.md\:pb-0{padding-bottom:calc(var(--spacing) * 0)}}@media(min-width:64rem){.lg\:block{display:block}.lg\:inline-flex{display:inline-flex}.lg\:w-56{width:calc(var(--spacing) * 56)}.lg\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.lg\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.lg\:grid-cols-\[1fr_280px\]{grid-template-columns:1fr 280px}.lg\:grid-cols-\[1fr_340px\]{grid-template-columns:1fr 340px}.lg\:grid-cols-\[1fr_360px\]{grid-template-columns:1fr 360px}.lg\:grid-cols-\[minmax\(0\,1fr\)_340px\]{grid-template-columns:minmax(0,1fr) 340px}}.\[\&\:\:-webkit-slider-thumb\]\:h-3::-webkit-slider-thumb{height:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:w-3::-webkit-slider-thumb{width:calc(var(--spacing) * 3)}.\[\&\:\:-webkit-slider-thumb\]\:appearance-none::-webkit-slider-thumb{-webkit-appearance:none;-moz-appearance:none;appearance:none}.\[\&\:\:-webkit-slider-thumb\]\:rounded-full::-webkit-slider-thumb{border-radius:3.40282e38px}.\[\&\:\:-webkit-slider-thumb\]\:bg-synapse-glow::-webkit-slider-thumb{background-color:var(--color-synapse-glow)}.\[\&\:\:-webkit-slider-thumb\]\:shadow-\[0_0_8px_rgba\(129\,140\,248\,0\.4\)\]::-webkit-slider-thumb{--tw-shadow:0 0 8px var(--tw-shadow-color,#818cf866);box-shadow:var(--tw-inset-shadow),var(--tw-inset-ring-shadow),var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow)}}html{background:var(--color-void);color:var(--color-text);font-family:var(--font-mono)}body{min-height:100vh;margin:0;overflow:hidden}::-webkit-scrollbar{width:6px;height:6px}::-webkit-scrollbar-track{background:0 0}::-webkit-scrollbar-thumb{background:var(--color-subtle);border-radius:3px}::-webkit-scrollbar-thumb:hover{background:var(--color-muted)}.glass{-webkit-backdrop-filter:blur(20px)saturate(180%);background:#16163873;border:1px solid #6366f114;box-shadow:inset 0 1px #ffffff08,0 4px 24px #0000004d}.glass-subtle{-webkit-backdrop-filter:blur(12px)saturate(150%);background:#10102a66;border:1px solid #6366f10f;box-shadow:inset 0 1px #ffffff05,0 2px 12px #0003}.glass-sidebar{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1a99;border-right:1px solid #6366f11a;box-shadow:inset -1px 0 #ffffff05,4px 0 24px #0000004d}.glass-panel{-webkit-backdrop-filter:blur(24px)saturate(180%);background:#0a0a1acc;border:1px solid #6366f11a;box-shadow:inset 0 1px #ffffff08,0 8px 32px #0006}.glow-synapse{box-shadow:0 0 20px #6366f14d,0 0 60px #6366f11a}.glow-dream{box-shadow:0 0 20px #a855f74d,0 0 60px #a855f71a}.glow-memory{box-shadow:0 0 20px #3b82f64d,0 0 60px #3b82f61a}@keyframes pulse-glow{0%,to{opacity:1}50%{opacity:.5}}.animate-pulse-glow{animation:2s ease-in-out infinite pulse-glow}@keyframes orb-float-1{0%,to{transform:translate(0)scale(1)}25%{transform:translate(60px,-40px)scale(1.1)}50%{transform:translate(-30px,-80px)scale(.95)}75%{transform:translate(-60px,-20px)scale(1.05)}}@keyframes orb-float-2{0%,to{transform:translate(0)scale(1)}25%{transform:translate(-50px,30px)scale(1.08)}50%{transform:translate(40px,60px)scale(.92)}75%{transform:translate(20px,-40px)scale(1.03)}}@keyframes orb-float-3{0%,to{transform:translate(0)scale(1)}25%{transform:translate(30px,50px)scale(1.05)}50%{transform:translate(-60px,20px)scale(.98)}75%{transform:translate(40px,-30px)scale(1.1)}}.ambient-orb{filter:blur(80px);pointer-events:none;z-index:0;opacity:.35;border-radius:50%;position:fixed}.ambient-orb-1{background:radial-gradient(circle,#a855f766,#0000 70%);width:400px;height:400px;animation:20s ease-in-out infinite orb-float-1;top:-10%;right:-5%}.ambient-orb-2{background:radial-gradient(circle,#6366f159,#0000 70%);width:350px;height:350px;animation:25s ease-in-out infinite orb-float-2;bottom:-15%;left:-5%}.ambient-orb-3{background:radial-gradient(circle,#f59e0b33,#0000 70%);width:300px;height:300px;animation:22s ease-in-out infinite orb-float-3;top:40%;left:40%}.nav-active-border{position:relative}.nav-active-border:before{content:"";background:linear-gradient(180deg,var(--color-synapse),var(--color-dream),var(--color-synapse));background-size:100% 200%;border-radius:1px;width:2px;animation:3s ease-in-out infinite gradient-shift;position:absolute;top:4px;bottom:4px;left:0}@keyframes gradient-shift{0%,to{background-position:0 0}50%{background-position:0 100%}}@keyframes float{0%,to{transform:translateY(0)translate(0)}25%{transform:translateY(-10px)translate(5px)}50%{transform:translateY(-5px)translate(-5px)}75%{transform:translateY(-15px)translate(3px)}}.retention-critical{color:var(--color-decay)}.retention-low{color:var(--color-warning)}.retention-good{color:var(--color-recall)}.retention-strong{color:var(--color-synapse)}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-scale-x{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-y{syntax:"*";inherits:false;initial-value:1}@property --tw-scale-z{syntax:"*";inherits:false;initial-value:1}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-gradient-position{syntax:"*";inherits:false}@property --tw-gradient-from{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-via{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-to{syntax:"";inherits:false;initial-value:#0000}@property --tw-gradient-stops{syntax:"*";inherits:false}@property --tw-gradient-via-stops{syntax:"*";inherits:false}@property --tw-gradient-from-position{syntax:"";inherits:false;initial-value:0%}@property --tw-gradient-via-position{syntax:"";inherits:false;initial-value:50%}@property --tw-gradient-to-position{syntax:"";inherits:false;initial-value:100%}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-backdrop-blur{syntax:"*";inherits:false}@property --tw-backdrop-brightness{syntax:"*";inherits:false}@property --tw-backdrop-contrast{syntax:"*";inherits:false}@property --tw-backdrop-grayscale{syntax:"*";inherits:false}@property --tw-backdrop-hue-rotate{syntax:"*";inherits:false}@property --tw-backdrop-invert{syntax:"*";inherits:false}@property --tw-backdrop-opacity{syntax:"*";inherits:false}@property --tw-backdrop-saturate{syntax:"*";inherits:false}@property --tw-backdrop-sepia{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-ease{syntax:"*";inherits:false}@keyframes spin{to{transform:rotate(360deg)}}@keyframes ping{75%,to{opacity:0;transform:scale(2)}}@keyframes pulse{50%{opacity:.5}}.toast-layer.svelte-pry2ep{position:fixed;z-index:60;pointer-events:none;display:flex;flex-direction:column;gap:.5rem;right:1.25rem;bottom:1.25rem;max-width:22rem;width:calc(100vw - 2.5rem)}@media(max-width:768px){.toast-layer.svelte-pry2ep{right:.75rem;left:.75rem;bottom:auto;top:5.25rem;max-width:none;width:auto;align-items:stretch}}.toast-item.svelte-pry2ep{pointer-events:auto;position:relative;display:flex;gap:.75rem;align-items:stretch;text-align:left;font:inherit;color:inherit;background:#0c0e16b8;backdrop-filter:blur(14px) saturate(160%);-webkit-backdrop-filter:blur(14px) saturate(160%);border:1px solid rgba(255,255,255,.06);border-radius:.75rem;padding:.75rem .9rem .75rem .5rem;overflow:hidden;box-shadow:0 10px 40px -12px #000c,0 0 22px -6px var(--toast-color);cursor:pointer;animation:svelte-pry2ep-toast-in .32s cubic-bezier(.16,1,.3,1);transform-origin:right center;transition:transform .15s ease,box-shadow .15s ease}.toast-item.svelte-pry2ep:hover{transform:translateY(-1px) scale(1.015);box-shadow:0 14px 48px -12px #000000d9,0 0 32px -4px var(--toast-color)}.toast-item.svelte-pry2ep:focus-visible{outline:1px solid var(--toast-color);outline-offset:2px}.toast-accent.svelte-pry2ep{width:3px;border-radius:2px;background:var(--toast-color);box-shadow:0 0 10px var(--toast-color);flex-shrink:0}.toast-body.svelte-pry2ep{display:flex;flex-direction:column;gap:.15rem;flex:1;min-width:0}.toast-head.svelte-pry2ep{display:flex;align-items:center;gap:.5rem}.toast-icon.svelte-pry2ep{color:var(--toast-color);font-size:.95rem;text-shadow:0 0 8px var(--toast-color);line-height:1;width:1rem;display:inline-flex;justify-content:center}.toast-title.svelte-pry2ep{color:#f5f5fa;font-size:.82rem;font-weight:600;letter-spacing:.01em}.toast-sub.svelte-pry2ep{color:#b0b6c4;font-size:.74rem;line-height:1.35;padding-left:1.5rem;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.toast-progress.svelte-pry2ep{position:absolute;left:0;bottom:0;height:2px;width:100%;background:#ffffff0a}.toast-progress-fill.svelte-pry2ep{height:100%;background:var(--toast-color);opacity:.55;transform-origin:left center;animation:svelte-pry2ep-toast-progress var(--toast-dwell) linear forwards}.toast-item.svelte-pry2ep:hover .toast-progress-fill:where(.svelte-pry2ep),.toast-item.svelte-pry2ep:focus-visible .toast-progress-fill:where(.svelte-pry2ep){animation-play-state:paused}@keyframes svelte-pry2ep-toast-in{0%{opacity:0;transform:translate(24px) scale(.98)}to{opacity:1;transform:translate(0) scale(1)}}@media(max-width:768px){.toast-item.svelte-pry2ep{transform-origin:top center;animation:svelte-pry2ep-toast-in-mobile .3s cubic-bezier(.16,1,.3,1)}}@keyframes svelte-pry2ep-toast-in-mobile{0%{opacity:0;transform:translateY(-12px) scale(.98)}to{opacity:1;transform:translateY(0) scale(1)}}@keyframes svelte-pry2ep-toast-progress{0%{transform:scaleX(1)}to{transform:scaleX(0)}}@media(prefers-reduced-motion:reduce){.toast-item.svelte-pry2ep{animation:none}.toast-progress-fill.svelte-pry2ep{animation:none;transform:scaleX(.5)}}.strip-item.svelte-1kk3799{display:inline-flex;align-items:center;gap:.4rem;padding:0 .75rem;white-space:nowrap;flex-shrink:0}.strip-divider.svelte-1kk3799{width:1px;height:14px;background:#6366f11f;flex-shrink:0}.ambient-strip.ambient-flash.svelte-1kk3799{background:linear-gradient(90deg,#ef444414,#ef444400 70%),#0006;border-bottom-color:#ef444459;transition:background .3s ease,border-color .3s ease}@keyframes svelte-1kk3799-ping-slow{0%{transform:scale(1);opacity:.8}80%,to{transform:scale(2);opacity:0}}.animate-ping-slow{animation:svelte-1kk3799-ping-slow 2.2s cubic-bezier(0,0,.2,1) infinite}@media(prefers-reduced-motion:reduce){.ambient-strip.svelte-1kk3799 .animate-ping,.ambient-strip.svelte-1kk3799 .animate-ping-slow,.ambient-strip.svelte-1kk3799 .animate-pulse{animation:none!important}}.verdict-bar.svelte-1j425e6{border-bottom:1px solid rgba(255,255,255,.06);background:#080912b8;backdrop-filter:blur(18px) saturate(160%);-webkit-backdrop-filter:blur(18px) saturate(160%);box-shadow:0 6px 24px #0000002e}.verdict-summary.svelte-1j425e6{width:100%;min-height:2.75rem;display:grid;grid-template-columns:auto auto minmax(0,1fr) auto;align-items:center;gap:.75rem;padding:.55rem 1rem;color:var(--color-text);text-align:left;font:inherit}.sr-only.svelte-1j425e6{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.label.svelte-1j425e6,.field-label.svelte-1j425e6,.appeal-row.svelte-1j425e6>span:where(.svelte-1j425e6){color:var(--color-dim);font-size:.68rem;text-transform:uppercase;letter-spacing:0}.levels.svelte-1j425e6{display:flex;align-items:center;gap:.25rem}.levels.svelte-1j425e6 span:where(.svelte-1j425e6){border:1px solid rgba(255,255,255,.08);border-radius:.35rem;padding:.18rem .38rem;color:var(--color-muted);font-size:.64rem;line-height:1}.levels.svelte-1j425e6 span.active:where(.svelte-1j425e6){color:var(--color-bright);border-color:var(--verdict-color);background:color-mix(in srgb,var(--verdict-color) 18%,transparent);box-shadow:0 0 14px color-mix(in srgb,var(--verdict-color) 28%,transparent)}.summary-text.svelte-1j425e6{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:.78rem;color:var(--color-dim)}.when.svelte-1j425e6{color:var(--color-muted);font-size:.68rem}.receipt.svelte-1j425e6{margin:0 1rem .75rem;border:1px solid rgba(255,255,255,.08);border-radius:.5rem;background:#0a0a1ac7;padding:.85rem}.receipt-grid.svelte-1j425e6{display:grid;grid-template-columns:minmax(0,1.4fr) minmax(10rem,.8fr) minmax(0,1.1fr) minmax(0,1.1fr);gap:.85rem}.receipt.svelte-1j425e6 p:where(.svelte-1j425e6),.receipt.svelte-1j425e6 li:where(.svelte-1j425e6){margin:.25rem 0 0;color:var(--color-text);font-size:.76rem;line-height:1.45;overflow-wrap:anywhere}.receipt.svelte-1j425e6 ul:where(.svelte-1j425e6){margin:.25rem 0 0;padding-left:1rem}.appeal-row.svelte-1j425e6{display:flex;align-items:center;gap:.4rem;margin-top:.85rem;flex-wrap:wrap}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6),.appeal-row.svelte-1j425e6 p:where(.svelte-1j425e6){border:1px solid rgba(255,255,255,.1);border-radius:.4rem;padding:.35rem .6rem;color:var(--color-text);background:#ffffff0a;font-size:.72rem;margin:0}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6):hover:not(:disabled),.verdict-summary.svelte-1j425e6:hover{background:#ffffff0d}.appeal-row.svelte-1j425e6 button:where(.svelte-1j425e6):disabled{opacity:.55;cursor:wait}.tone-pass.svelte-1j425e6,.tone-note.svelte-1j425e6{--verdict-color: #10b981}.tone-caution.svelte-1j425e6{--verdict-color: #f59e0b}.tone-veto.svelte-1j425e6{--verdict-color: #ef4444}.tone-appealed.svelte-1j425e6{--verdict-color: #818cf8}@media(max-width:900px){.verdict-summary.svelte-1j425e6{grid-template-columns:auto minmax(0,1fr) auto}.levels.svelte-1j425e6{grid-column:1 / -1;order:4;overflow-x:auto;padding-bottom:.1rem}.receipt-grid.svelte-1j425e6{grid-template-columns:1fr}}.theme-toggle.svelte-1cmi4dh{width:30px;height:30px;display:inline-flex;align-items:center;justify-content:center;padding:0;border-radius:8px;background:#6366f10f;border:1px solid rgba(99,102,241,.14);color:var(--color-text);cursor:pointer;transition:background .2s ease,border-color .2s ease,color .2s ease,transform .12s ease;-webkit-tap-highlight-color:transparent}.theme-toggle.svelte-1cmi4dh:hover{background:#6366f124;border-color:#6366f14d;color:var(--color-bright)}.theme-toggle.svelte-1cmi4dh:active{transform:scale(.94)}.theme-toggle.svelte-1cmi4dh:focus-visible{outline:1px solid var(--color-synapse);outline-offset:2px}.icon-wrap.svelte-1cmi4dh{position:relative;width:18px;height:18px;display:inline-block}.icon.svelte-1cmi4dh{position:absolute;top:0;right:0;bottom:0;left:0;width:18px;height:18px;opacity:0;transform:scale(.7) rotate(-30deg);transition:opacity .2s ease,transform .2s cubic-bezier(.16,1,.3,1);pointer-events:none}.icon.active.svelte-1cmi4dh{opacity:1;transform:scale(1) rotate(0)}.theme-toggle[data-mode=dark].svelte-1cmi4dh{color:var(--color-synapse-glow, #818cf8)}.theme-toggle[data-mode=light].svelte-1cmi4dh{color:var(--color-warning, #f59e0b)}.theme-toggle[data-mode=auto].svelte-1cmi4dh{color:var(--color-dream-glow, #c084fc)}@media(prefers-reduced-motion:reduce){.theme-toggle.svelte-1cmi4dh,.icon.svelte-1cmi4dh{transition:none}}.safe-bottom.svelte-12qhfyh{padding-bottom:env(safe-area-inset-bottom,0px)}@keyframes svelte-12qhfyh-page-in{0%{opacity:0;transform:translateY(4px)}to{opacity:1;transform:translateY(0)}}.animate-page-in.svelte-12qhfyh{animation:svelte-12qhfyh-page-in .2s ease-out} diff --git a/apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css.br b/apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css.br new file mode 100644 index 0000000000000000000000000000000000000000..ace1ff437589234eefa27803dc60b61a0f2af0b7 GIT binary patch literal 10347 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 J4!!Y4$1lz*BLM&a literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css.gz b/apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css.gz similarity index 70% rename from apps/dashboard/build/_app/immutable/assets/0.CN9L-NIY.css.gz rename to apps/dashboard/build/_app/immutable/assets/0.Bor8S3Zo.css.gz index 9e9b96053c316175564aeb53044f70013e738823..9bfd30867ad3ea5f4eb0e4dbaad0862a2259fd13 100644 GIT binary patch delta 3575 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

      ;Ec~Y*D!@u8*ko*?#!Q)l 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 o=e?"?"+new URLSearchParams(e).toString():"";return t(`/memories${o}`)},get:e=>t(`/memories/${e}`),delete:e=>t(`/memories/${e}`,{method:"DELETE"}),promote:e=>t(`/memories/${e}/promote`,{method:"POST"}),demote:e=>t(`/memories/${e}/demote`,{method:"POST"}),suppress:(e,o)=>t(`/memories/${e}/suppress`,{method:"POST",body:o?JSON.stringify({reason:o}):void 0}),unsuppress:e=>t(`/memories/${e}/unsuppress`,{method:"POST"})},search:(e,o=20)=>t(`/search?q=${encodeURIComponent(e)}&limit=${o}`),stats:()=>t("/stats"),health:()=>t("/health"),timeline:(e=7,o=200)=>t(`/timeline?days=${e}&limit=${o}`),graph:e=>{const o=e?"?"+new URLSearchParams(Object.entries(e).filter(([,i])=>i!==void 0).map(([i,s])=>[i,String(s)])).toString():"";return t(`/graph${o}`)},dream:()=>t("/dream",{method:"POST"}),explore:(e,o="associations",i,s=10)=>t("/explore",{method:"POST",body:JSON.stringify({from_id:e,action:o,to_id:i,limit:s})}),predict:()=>t("/predict",{method:"POST"}),importance:e=>t("/importance",{method:"POST",body:JSON.stringify({content:e})}),consolidate:()=>t("/consolidate",{method:"POST"}),retentionDistribution:()=>t("/retention-distribution"),intentions:(e="active")=>t(`/intentions?status=${e}`),deepReference:(e,o=20)=>t("/deep_reference",{method:"POST",body:JSON.stringify({query:e,depth:o})}),sanhedrin:{latest:()=>t("/sanhedrin/latest"),appeal:(e,o,i,s)=>t("/sanhedrin/appeal",{method:"POST",body:JSON.stringify({reason:e,note:o,claimId:i,receiptId:s})})}};export{n as a}; +const r="/api";async function t(e,o){const i=await fetch(`${r}${e}`,{headers:{"Content-Type":"application/json"},...o});if(!i.ok)throw new Error(`API ${i.status}: ${i.statusText}`);return i.json()}const n={memories:{list:e=>{const o=e?"?"+new URLSearchParams(e).toString():"";return t(`/memories${o}`)},get:e=>t(`/memories/${e}`),delete:e=>t(`/memories/${e}`,{method:"DELETE"}),promote:e=>t(`/memories/${e}/promote`,{method:"POST"}),demote:e=>t(`/memories/${e}/demote`,{method:"POST"}),suppress:(e,o)=>t(`/memories/${e}/suppress`,{method:"POST",body:o?JSON.stringify({reason:o}):void 0}),unsuppress:e=>t(`/memories/${e}/unsuppress`,{method:"POST"})},search:(e,o=20)=>t(`/search?q=${encodeURIComponent(e)}&limit=${o}`),stats:()=>t("/stats"),health:()=>t("/health"),timeline:(e=7,o=200)=>t(`/timeline?days=${e}&limit=${o}`),graph:e=>{const o=e?"?"+new URLSearchParams(Object.entries(e).filter(([,i])=>i!==void 0).map(([i,s])=>[i,String(s)])).toString():"";return t(`/graph${o}`)},dream:()=>t("/dream",{method:"POST"}),explore:(e,o="associations",i,s=10)=>t("/explore",{method:"POST",body:JSON.stringify({from_id:e,action:o,to_id:i,limit:s})}),predict:()=>t("/predict",{method:"POST"}),importance:e=>t("/importance",{method:"POST",body:JSON.stringify({content:e})}),consolidate:()=>t("/consolidate",{method:"POST"}),retentionDistribution:()=>t("/retention-distribution"),intentions:(e="active")=>t(`/intentions?status=${e}`),deepReference:(e,o=20)=>t("/deep_reference",{method:"POST",body:JSON.stringify({query:e,depth:o})}),sanhedrin:{latest:()=>t("/sanhedrin/latest"),telemetry:(e=7)=>t(`/sanhedrin/telemetry?days=${e}`),appeal:(e,o,i,s)=>t("/sanhedrin/appeal",{method:"POST",body:JSON.stringify({reason:e,note:o,claimId:i,receiptId:s})})}};export{n as a}; diff --git a/apps/dashboard/build/_app/immutable/chunks/B7CfdQuM.js.br b/apps/dashboard/build/_app/immutable/chunks/B7CfdQuM.js.br new file mode 100644 index 0000000000000000000000000000000000000000..d93874181fbfac113a243da8c24b659269520584 GIT binary patch literal 646 zcmV;10(t!#+XeuP)LN}JY}?Z5o@H`WdRXyu~xbAY%b+MUk zKZM853b+j>zn96b*=+HU=wXaS$-`$$Y0o*`vaB)n&A;Z7K$&m}r4Tp~O75$nV#33^i zf+?LKO%72xcBLADSu5K~_)RPNwp<#LM>=t#;NXCO1Cp1o4G|_P8vqrIfyv=Sptq2dFRlp^zq gM1_0p8dTk#F4dahx&~I%eKMG#LXJh%e}#N90ut>otN;K2 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/B7CfdQuM.js.gz b/apps/dashboard/build/_app/immutable/chunks/B7CfdQuM.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..fc0e3561a2ee61df289f5fffd127516bb6d9a7c9 GIT binary patch literal 774 zcmV+h1Nrt<9#v*7g#L=M^{H9J<)g0zQMn+jOML{$}-3FmA4V3cGHkKRj`=z!GiR_J=!} zP?Fx5js1y5oa9;9)o|S&>E2=q1xlcp>31Ks58ETtTx^Vs{VLAA7S-y5@;bkJfXv3k z*Hyx)ZHa{i9fp56-cUe1NYl24QCy0O?vWb@(6^JNiEg6*sMOQxC7M%f${|^QVs8}z zFIAy5wB=^P7?q))Q^PogPrn{@4!VbIuP$DzVo9>S#XJEn`~pc7x5`~0_w`E*b=pZE za?I>NvODjgiPUOsh0Hp|v+?%kW0bOXBPHM?yLPDpb3r52N8h>I!+^?6=9J3`I99kfx`ZWYa2fB80(FwGTit^nOa5^U zdPCjFp`rm$z63_d73B1UmL#QYwrv=YaSON+p`}J~$cdYgekg}`1H2s+%7V5&jhLtJ zwDiV%i+?PGZqERhZtE$Y6#~msCnyaWU}fpwi>hfRBvq0|EdyZ!(M&%51D#Y%`rHNp E02TCiY5)KL literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js b/apps/dashboard/build/_app/immutable/chunks/C2TQQEIa.js similarity index 65% rename from apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js rename to apps/dashboard/build/_app/immutable/chunks/C2TQQEIa.js index d17266c..d683bb6 100644 --- a/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js +++ b/apps/dashboard/build/_app/immutable/chunks/C2TQQEIa.js @@ -1 +1 @@ -import{$ as J,bd as ee}from"./CpWkWWOo.js";import{w as ae}from"./BeMFXnHE.js";import{c as ne,H as N,N as B,r as gt,i as _t,b as L,s as C,p as x,n as ft,f as $t,g as ut,a as X,d as it,S as Nt,P as re,e as oe,h as se,o as Dt,j as q,k as ie,l as qt,m as ce,q as le,t as Kt,u as Pt,v as fe}from"./DGcYlAAw.js";class wt{constructor(a,e){this.status=a,typeof e=="string"?this.body={message:e}:e?this.body=e:this.body={message:`Error: ${a}`}}toString(){return JSON.stringify(this.body)}}class vt{constructor(a,e){this.status=a,this.location=e}}class yt extends Error{constructor(a,e,r){super(r),this.status=a,this.text=e}}const ue=/^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;function he(t){const a=[];return{pattern:t==="/"?/^\/$/:new RegExp(`^${pe(t).map(r=>{const n=/^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(r);if(n)return a.push({name:n[1],matcher:n[2],optional:!1,rest:!0,chained:!0}),"(?:/([^]*))?";const o=/^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(r);if(o)return a.push({name:o[1],matcher:o[2],optional:!0,rest:!1,chained:!0}),"(?:/([^/]+))?";if(!r)return;const s=r.split(/\[(.+?)\](?!\])/);return"/"+s.map((c,l)=>{if(l%2){if(c.startsWith("x+"))return ct(String.fromCharCode(parseInt(c.slice(2),16)));if(c.startsWith("u+"))return ct(String.fromCharCode(...c.slice(2).split("-").map(_=>parseInt(_,16))));const h=ue.exec(c),[,u,w,f,d]=h;return a.push({name:f,matcher:d,optional:!!u,rest:!!w,chained:w?l===1&&s[0]==="":!1}),w?"([^]*?)":u?"([^/]*)?":"([^/]+?)"}return ct(c)}).join("")}).join("")}/?$`),params:a}}function de(t){return t!==""&&!/^\([^)]+\)$/.test(t)}function pe(t){return t.slice(1).split("/").filter(de)}function me(t,a,e){const r={},n=t.slice(1),o=n.filter(i=>i!==void 0);let s=0;for(let i=0;ih).join("/"),s=0),l===void 0)if(c.rest)l="";else continue;if(!c.matcher||e[c.matcher](l)){r[c.name]=l;const h=a[i+1],u=n[i+1];h&&!h.rest&&h.optional&&u&&c.chained&&(s=0),!h&&!u&&Object.keys(r).length===o.length&&(s=0);continue}if(c.optional&&c.chained){s++;continue}return}if(!s)return r}function ct(t){return t.normalize().replace(/[[\]]/g,"\\$&").replace(/%/g,"%25").replace(/\//g,"%2[Ff]").replace(/\?/g,"%3[Ff]").replace(/#/g,"%23").replace(/[.*+?^${}()|\\]/g,"\\$&")}function ge({nodes:t,server_loads:a,dictionary:e,matchers:r}){const n=new Set(a);return Object.entries(e).map(([i,[c,l,h]])=>{const{pattern:u,params:w}=he(i),f={id:i,exec:d=>{const _=u.exec(d);if(_)return me(_,w,r)},errors:[1,...h||[]].map(d=>t[d]),layouts:[0,...l||[]].map(s),leaf:o(c)};return f.errors.length=f.layouts.length=Math.max(f.errors.length,f.layouts.length),f});function o(i){const c=i<0;return c&&(i=~i),[c,t[i]]}function s(i){return i===void 0?i:[n.has(i),t[i]]}}function Ft(t,a=JSON.parse){try{return a(sessionStorage[t])}catch{}}function It(t,a,e=JSON.stringify){const r=e(a);try{sessionStorage[t]=r}catch{}}function _e(t){return t.filter(a=>a!=null)}function Et(t){return t instanceof wt||t instanceof yt?t.status:500}function we(t){return t instanceof yt?t.text:"Internal Error"}const ve=new Set(["icon","shortcut icon","apple-touch-icon"]),I=Ft(Kt)??{},M=Ft(qt)??{},P={url:Pt({}),page:Pt({}),navigating:ae(null),updated:ne()};function bt(t){I[t]=C()}function ye(t,a){let e=t+1;for(;I[e];)delete I[e],e+=1;for(e=a+1;M[e];)delete M[e],e+=1}function V(t,a=!1){return a?location.replace(t.href):location.href=t.href,new Promise(()=>{})}async function Bt(){if("serviceWorker"in navigator){const t=await navigator.serviceWorker.getRegistration(L||"/");t&&await t.update()}}function Tt(){}let kt,ht,Q,U,dt,b;const Z=[],tt=[];let v=null;function pt(){var t;(t=v==null?void 0:v.fork)==null||t.then(a=>a==null?void 0:a.discard()),v=null}const G=new Map,Mt=new Set,Ee=new Set,F=new Set;let g={branch:[],error:null,url:null},Vt=!1,et=!1,Ot=!0,H=!1,K=!1,Ht=!1,St=!1,Yt,E,R,O;const at=new Set,Ct=new Map;async function Fe(t,a,e){var o,s,i,c,l;(o=globalThis.__sveltekit_1r5nume)!=null&&o.data&&globalThis.__sveltekit_1r5nume.data,document.URL!==location.href&&(location.href=location.href),b=t,await((i=(s=t.hooks).init)==null?void 0:i.call(s)),kt=ge(t),U=document.documentElement,dt=a,ht=t.nodes[0],Q=t.nodes[1],ht(),Q(),E=(c=history.state)==null?void 0:c[N],R=(l=history.state)==null?void 0:l[B],E||(E=R=Date.now(),history.replaceState({...history.state,[N]:E,[B]:R},""));const r=I[E];function n(){r&&(history.scrollRestoration="manual",scrollTo(r.x,r.y))}e?(n(),await Ce(dt,e)):(await D({type:"enter",url:gt(b.hash?Ne(new URL(location.href)):location.href),replace_state:!0}),n()),Oe()}function be(){Z.length=0,St=!1}function zt(t){tt.some(a=>a==null?void 0:a.snapshot)&&(M[t]=tt.map(a=>{var e;return(e=a==null?void 0:a.snapshot)==null?void 0:e.capture()}))}function Wt(t){var a;(a=M[t])==null||a.forEach((e,r)=>{var n,o;(o=(n=tt[r])==null?void 0:n.snapshot)==null||o.restore(e)})}function jt(){bt(E),It(Kt,I),zt(R),It(qt,M)}async function Gt(t,a,e,r){let n;a.invalidateAll&&pt(),await D({type:"goto",url:gt(t),keepfocus:a.keepFocus,noscroll:a.noScroll,replace_state:a.replaceState,state:a.state,redirect_count:e,nav_token:r,accept:()=>{a.invalidateAll&&(St=!0,n=[...Ct.keys()]),a.invalidate&&a.invalidate.forEach(Te)}}),a.invalidateAll&&J().then(J).then(()=>{Ct.forEach(({resource:o},s)=>{var i;n!=null&&n.includes(s)&&((i=o.refresh)==null||i.call(o))})})}async function ke(t){if(t.id!==(v==null?void 0:v.id)){pt();const a={};at.add(a),v={id:t.id,token:a,promise:Xt({...t,preload:a}).then(e=>(at.delete(a),e.type==="loaded"&&e.state.error&&pt(),e)),fork:null}}return v.promise}async function lt(t){var e;const a=(e=await ot(t,!1))==null?void 0:e.route;a&&await Promise.all([...a.layouts,a.leaf].filter(Boolean).map(r=>r[1]()))}async function Jt(t,a,e){var n;g=t.state;const r=document.querySelector("style[data-sveltekit]");if(r&&r.remove(),Object.assign(x,t.props.page),Yt=new b.root({target:a,props:{...t.props,stores:P,components:tt},hydrate:e,sync:!1}),await Promise.resolve(),Wt(R),e){const o={from:null,to:{params:g.params,route:{id:((n=g.route)==null?void 0:n.id)??null},url:new URL(location.href),scroll:I[E]??C()},willUnload:!1,type:"enter",complete:Promise.resolve()};F.forEach(s=>s(o))}et=!0}function nt({url:t,params:a,branch:e,status:r,error:n,route:o,form:s}){let i="never";if(L&&(t.pathname===L||t.pathname===L+"/"))i="always";else for(const f of e)(f==null?void 0:f.slash)!==void 0&&(i=f.slash);t.pathname=se(t.pathname,i),t.search=t.search;const c={type:"loaded",state:{url:t,params:a,branch:e,error:n,route:o},props:{constructors:_e(e).map(f=>f.node.component),page:At(x)}};s!==void 0&&(c.props.form=s);let l={},h=!x,u=0;for(let f=0;fi(new URL(s))))return!0;return!1}function xt(t,a){return(t==null?void 0:t.type)==="data"?t:(t==null?void 0:t.type)==="skip"?a??null:null}function xe(t,a){if(!t)return new Set(a.searchParams.keys());const e=new Set([...t.searchParams.keys(),...a.searchParams.keys()]);for(const r of e){const n=t.searchParams.getAll(r),o=a.searchParams.getAll(r);n.every(s=>o.includes(s))&&o.every(s=>n.includes(s))&&e.delete(r)}return e}function Le({error:t,url:a,route:e,params:r}){return{type:"loaded",state:{error:t,url:a,route:e,params:r,branch:[]},props:{page:At(x),constructors:[]}}}async function Xt({id:t,invalidating:a,url:e,params:r,route:n,preload:o}){if((v==null?void 0:v.id)===t)return at.delete(v.token),v.promise;const{errors:s,layouts:i,leaf:c}=n,l=[...i,c];s.forEach(m=>m==null?void 0:m().catch(()=>{})),l.forEach(m=>m==null?void 0:m[1]().catch(()=>{}));const h=g.url?t!==rt(g.url):!1,u=g.route?n.id!==g.route.id:!1,w=xe(g.url,e);let f=!1;const d=l.map(async(m,p)=>{var A;if(!m)return;const y=g.branch[p];return m[1]===(y==null?void 0:y.loader)&&!Re(f,u,h,w,(A=y.universal)==null?void 0:A.uses,r)?y:(f=!0,Rt({loader:m[1],url:e,params:r,route:n,parent:async()=>{var z;const T={};for(let j=0;j{});const _=[];for(let m=0;mPromise.resolve({}),server_data_node:xt(o)}),i={node:await Q(),loader:Q,universal:null,server:null,data:null};return nt({url:e,params:n,branch:[s,i],status:t,error:a,route:null})}catch(s){if(s instanceof vt)return Gt(new URL(s.location,location.href),{},0);throw s}}async function Ae(t){const a=t.href;if(G.has(a))return G.get(a);let e;try{const r=(async()=>{let n=await b.hooks.reroute({url:new URL(t),fetch:async(o,s)=>Se(o,s,t).promise})??t;if(typeof n=="string"){const o=new URL(t);b.hash?o.hash=n:o.pathname=n,n=o}return n})();G.set(a,r),e=await r}catch{G.delete(a);return}return e}async function ot(t,a){if(t&&!_t(t,L,b.hash)){const e=await Ae(t);if(!e)return;const r=Pe(e);for(const n of kt){const o=n.exec(r);if(o)return{id:rt(t),invalidating:a,route:n,params:oe(o),url:t}}}}function Pe(t){return ie(b.hash?t.hash.replace(/^#/,"").replace(/[?#].+/,""):t.pathname.slice(L.length))||"/"}function rt(t){return(b.hash?t.hash.replace(/^#/,""):t.pathname)+t.search}function Qt({url:t,type:a,intent:e,delta:r,event:n,scroll:o}){let s=!1;const i=Ut(g,e,t,a,o??null);r!==void 0&&(i.navigation.delta=r),n!==void 0&&(i.navigation.event=n);const c={...i.navigation,cancel:()=>{s=!0,i.reject(new Error("navigation cancelled"))}};return H||Mt.forEach(l=>l(c)),s?null:i}async function D({type:t,url:a,popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s={},redirect_count:i=0,nav_token:c={},accept:l=Tt,block:h=Tt,event:u}){var j;const w=O;O=c;const f=await ot(a,!1),d=t==="enter"?Ut(g,f,a,t):Qt({url:a,type:t,delta:e==null?void 0:e.delta,intent:f,scroll:e==null?void 0:e.scroll,event:u});if(!d){h(),O===c&&(O=w);return}const _=E,m=R;l(),H=!0,et&&d.navigation.type!=="enter"&&P.navigating.set(ft.current=d.navigation);let p=f&&await Xt(f);if(!p){if(_t(a,L,b.hash))return await V(a,o);p=await Zt(a,{id:null},await Y(new yt(404,"Not Found",`Not found: ${a.pathname}`),{url:a,params:{},route:{id:null}}),404,o)}if(a=(f==null?void 0:f.url)||a,O!==c)return d.reject(new Error("navigation aborted")),!1;if(p.type==="redirect"){if(i<20){await D({type:t,url:new URL(p.location,a),popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s,redirect_count:i+1,nav_token:c}),d.fulfil(void 0);return}p=await Lt({status:500,error:await Y(new Error("Redirect loop"),{url:a,params:{},route:{id:null}}),url:a,route:{id:null}})}else p.props.page.status>=400&&await P.updated.check()&&(await Bt(),await V(a,o));if(be(),bt(_),zt(m),p.props.page.url.pathname!==a.pathname&&(a.pathname=p.props.page.url.pathname),s=e?e.state:s,!e){const k=o?0:1,W={[N]:E+=k,[B]:R+=k,[Nt]:s};(o?history.replaceState:history.pushState).call(history,W,"",a),o||ye(E,R)}const y=f&&(v==null?void 0:v.id)===f.id?v.fork:null;v=null,p.props.page.state=s;let S;if(et){const k=(await Promise.all(Array.from(Ee,$=>$(d.navigation)))).filter($=>typeof $=="function");if(k.length>0){let $=function(){k.forEach(st=>{F.delete(st)})};k.push($),k.forEach(st=>{F.add(st)})}g=p.state,p.props.page&&(p.props.page.url=a);const W=y&&await y;W?S=W.commit():(Yt.$set(p.props),fe(p.props.page),S=(j=ee)==null?void 0:j()),Ht=!0}else await Jt(p,dt,!1);const{activeElement:A}=document;await S,await J(),await J();let T=null;if(Ot){const k=e?e.scroll:n?C():null;k?scrollTo(k.x,k.y):(T=a.hash&&document.getElementById(te(a)))?T.scrollIntoView():scrollTo(0,0)}const z=document.activeElement!==A&&document.activeElement!==document.body;!r&&!z&&$e(a,!T),Ot=!0,p.props.page&&Object.assign(x,p.props.page),H=!1,t==="popstate"&&Wt(R),d.fulfil(void 0),d.navigation.to&&(d.navigation.to.scroll=C()),F.forEach(k=>k(d.navigation)),P.navigating.set(ft.current=null)}async function Zt(t,a,e,r,n){return t.origin===Dt&&t.pathname===location.pathname&&!Vt?await Lt({status:r,error:e,url:t,route:a}):await V(t,n)}function Ie(){let t,a={element:void 0,href:void 0},e;U.addEventListener("mousemove",i=>{const c=i.target;clearTimeout(t),t=setTimeout(()=>{o(c,q.hover)},20)});function r(i){i.defaultPrevented||o(i.composedPath()[0],q.tap)}U.addEventListener("mousedown",r),U.addEventListener("touchstart",r,{passive:!0});const n=new IntersectionObserver(i=>{for(const c of i)c.isIntersecting&&(lt(new URL(c.target.href)),n.unobserve(c.target))},{threshold:0});async function o(i,c){const l=$t(i,U),h=l===a.element&&(l==null?void 0:l.href)===a.href&&c>=e;if(!l||h)return;const{url:u,external:w,download:f}=ut(l,L,b.hash);if(w||f)return;const d=X(l),_=u&&rt(g.url)===rt(u);if(!(d.reload||_))if(c<=d.preload_data){a={element:l,href:l.href},e=q.tap;const m=await ot(u,!1);if(!m)return;ke(m)}else c<=d.preload_code&&(a={element:l,href:l.href},e=c,lt(u))}function s(){n.disconnect();for(const i of U.querySelectorAll("a")){const{url:c,external:l,download:h}=ut(i,L,b.hash);if(l||h)continue;const u=X(i);u.reload||(u.preload_code===q.viewport&&n.observe(i),u.preload_code===q.eager&<(c))}}F.add(s),s()}function Y(t,a){if(t instanceof wt)return t.body;const e=Et(t),r=we(t);return b.hooks.handleError({error:t,event:a,status:e,message:r})??{message:r}}function Be(t,a={}){return t=new URL(gt(t)),t.origin!==Dt?Promise.reject(new Error("goto: invalid URL")):Gt(t,a,0)}function Te(t){if(typeof t=="function")Z.push(t);else{const{href:a}=new URL(t,location.href);Z.push(e=>e.href===a)}}function Oe(){var a;history.scrollRestoration="manual",addEventListener("beforeunload",e=>{let r=!1;if(jt(),!H){const n=Ut(g,void 0,null,"leave"),o={...n.navigation,cancel:()=>{r=!0,n.reject(new Error("navigation cancelled"))}};Mt.forEach(s=>s(o))}r?(e.preventDefault(),e.returnValue=""):history.scrollRestoration="auto"}),addEventListener("visibilitychange",()=>{document.visibilityState==="hidden"&&jt()}),(a=navigator.connection)!=null&&a.saveData||Ie(),U.addEventListener("click",async e=>{if(e.button||e.which!==1||e.metaKey||e.ctrlKey||e.shiftKey||e.altKey||e.defaultPrevented)return;const r=$t(e.composedPath()[0],U);if(!r)return;const{url:n,external:o,target:s,download:i}=ut(r,L,b.hash);if(!n)return;if(s==="_parent"||s==="_top"){if(window.parent!==window)return}else if(s&&s!=="_self")return;const c=X(r);if(!(r instanceof SVGAElement)&&n.protocol!==location.protocol&&!(n.protocol==="https:"||n.protocol==="http:")||i)return;const[h,u]=(b.hash?n.hash.replace(/^#/,""):n.href).split("#"),w=h===it(location);if(o||c.reload&&(!w||!u)){Qt({url:n,type:"link",event:e})?H=!0:e.preventDefault();return}if(u!==void 0&&w){const[,f]=g.url.href.split("#");if(f===u){if(e.preventDefault(),u===""||u==="top"&&r.ownerDocument.getElementById("top")===null)scrollTo({top:0});else{const d=r.ownerDocument.getElementById(decodeURIComponent(u));d&&(d.scrollIntoView(),d.focus())}return}if(K=!0,bt(E),t(n),!c.replace_state)return;K=!1}e.preventDefault(),await new Promise(f=>{requestAnimationFrame(()=>{setTimeout(f,0)}),setTimeout(f,100)}),await D({type:"link",url:n,keepfocus:c.keepfocus,noscroll:c.noscroll,replace_state:c.replace_state??n.href===location.href,event:e})}),U.addEventListener("submit",e=>{if(e.defaultPrevented)return;const r=HTMLFormElement.prototype.cloneNode.call(e.target),n=e.submitter;if(((n==null?void 0:n.formTarget)||r.target)==="_blank"||((n==null?void 0:n.formMethod)||r.method)!=="get")return;const i=new URL((n==null?void 0:n.hasAttribute("formaction"))&&(n==null?void 0:n.formAction)||r.action);if(_t(i,L,!1))return;const c=e.target,l=X(c);if(l.reload)return;e.preventDefault(),e.stopPropagation();const h=new FormData(c,n);i.search=new URLSearchParams(h).toString(),D({type:"form",url:i,keepfocus:l.keepfocus,noscroll:l.noscroll,replace_state:l.replace_state??i.href===location.href,event:e})}),addEventListener("popstate",async e=>{var r;if(!mt){if((r=e.state)!=null&&r[N]){const n=e.state[N];if(O={},n===E)return;const o=I[n],s=e.state[Nt]??{},i=new URL(e.state[re]??location.href),c=e.state[B],l=g.url?it(location)===it(g.url):!1;if(c===R&&(Ht||l)){s!==x.state&&(x.state=s),t(i),I[E]=C(),o&&scrollTo(o.x,o.y),E=n;return}const u=n-E;await D({type:"popstate",url:i,popped:{state:s,scroll:o,delta:u},accept:()=>{E=n,R=c},block:()=>{history.go(-u)},nav_token:O,event:e})}else if(!K){const n=new URL(location.href);t(n),b.hash&&location.reload()}}}),addEventListener("hashchange",()=>{K&&(K=!1,history.replaceState({...history.state,[N]:++E,[B]:R},"",location.href))});for(const e of document.querySelectorAll("link"))ve.has(e.rel)&&(e.href=e.href);addEventListener("pageshow",e=>{e.persisted&&P.navigating.set(ft.current=null)});function t(e){g.url=x.url=e,P.page.set(At(x)),P.page.notify()}}async function Ce(t,{status:a=200,error:e,node_ids:r,params:n,route:o,server_route:s,data:i,form:c}){Vt=!0;const l=new URL(location.href);let h;({params:n={},route:o={id:null}}=await ot(l,!1)||{}),h=kt.find(({id:f})=>f===o.id);let u,w=!0;try{const f=r.map(async(_,m)=>{const p=i[m];return p!=null&&p.uses&&(p.uses=je(p.uses)),Rt({loader:b.nodes[_],url:l,params:n,route:o,parent:async()=>{const y={};for(let S=0;S{const i=history.state;mt=!0,location.replace(new URL(`#${r}`,location.href)),history.replaceState(i,"",t),a&&scrollTo(o,s),mt=!1})}else{const o=document.body,s=o.getAttribute("tabindex");o.tabIndex=-1,o.focus({preventScroll:!0,focusVisible:!1}),s!==null?o.setAttribute("tabindex",s):o.removeAttribute("tabindex")}const n=getSelection();if(n&&n.type!=="None"){const o=[];for(let s=0;s{if(n.rangeCount===o.length){for(let s=0;s{o=u,s=w});return i.catch(()=>{}),{navigation:{from:{params:t.params,route:{id:((l=t.route)==null?void 0:l.id)??null},url:t.url,scroll:C()},to:e&&{params:(a==null?void 0:a.params)??null,route:{id:((h=a==null?void 0:a.route)==null?void 0:h.id)??null},url:e,scroll:n},willUnload:!a,type:r,complete:i},fulfil:o,reject:s}}function At(t){return{data:t.data,error:t.error,form:t.form,params:t.params,route:t.route,state:t.state,status:t.status,url:t.url}}function Ne(t){const a=new URL(t);return a.hash=decodeURIComponent(t.hash),a}function te(t){let a;if(b.hash){const[,,e]=t.hash.split("#",3);a=e??""}else a=t.hash.slice(1);return decodeURIComponent(a)}export{Fe as a,Be as g,P as s}; +import{$ as J,bd as ee}from"./CpWkWWOo.js";import{w as ae}from"./BeMFXnHE.js";import{c as ne,H as N,N as B,r as mt,i as _t,b as L,s as C,p as x,n as ft,f as $t,g as ut,a as X,d as it,S as Nt,P as re,e as oe,h as se,o as Dt,j as q,k as ie,l as qt,m as le,q as ce,t as Kt,u as Pt,v as fe}from"./D8UfWY0j.js";class wt{constructor(a,e){this.status=a,typeof e=="string"?this.body={message:e}:e?this.body=e:this.body={message:`Error: ${a}`}}toString(){return JSON.stringify(this.body)}}class vt{constructor(a,e){this.status=a,this.location=e}}class yt extends Error{constructor(a,e,r){super(r),this.status=a,this.text=e}}const ue=/^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;function he(t){const a=[];return{pattern:t==="/"?/^\/$/:new RegExp(`^${pe(t).map(r=>{const n=/^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(r);if(n)return a.push({name:n[1],matcher:n[2],optional:!1,rest:!0,chained:!0}),"(?:/([^]*))?";const o=/^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(r);if(o)return a.push({name:o[1],matcher:o[2],optional:!0,rest:!1,chained:!0}),"(?:/([^/]+))?";if(!r)return;const s=r.split(/\[(.+?)\](?!\])/);return"/"+s.map((l,c)=>{if(c%2){if(l.startsWith("x+"))return lt(String.fromCharCode(parseInt(l.slice(2),16)));if(l.startsWith("u+"))return lt(String.fromCharCode(...l.slice(2).split("-").map(_=>parseInt(_,16))));const h=ue.exec(l),[,u,w,f,d]=h;return a.push({name:f,matcher:d,optional:!!u,rest:!!w,chained:w?c===1&&s[0]==="":!1}),w?"([^]*?)":u?"([^/]*)?":"([^/]+?)"}return lt(l)}).join("")}).join("")}/?$`),params:a}}function de(t){return t!==""&&!/^\([^)]+\)$/.test(t)}function pe(t){return t.slice(1).split("/").filter(de)}function ge(t,a,e){const r={},n=t.slice(1),o=n.filter(i=>i!==void 0);let s=0;for(let i=0;ih).join("/"),s=0),c===void 0)if(l.rest)c="";else continue;if(!l.matcher||e[l.matcher](c)){r[l.name]=c;const h=a[i+1],u=n[i+1];h&&!h.rest&&h.optional&&u&&l.chained&&(s=0),!h&&!u&&Object.keys(r).length===o.length&&(s=0);continue}if(l.optional&&l.chained){s++;continue}return}if(!s)return r}function lt(t){return t.normalize().replace(/[[\]]/g,"\\$&").replace(/%/g,"%25").replace(/\//g,"%2[Ff]").replace(/\?/g,"%3[Ff]").replace(/#/g,"%23").replace(/[.*+?^${}()|\\]/g,"\\$&")}function me({nodes:t,server_loads:a,dictionary:e,matchers:r}){const n=new Set(a);return Object.entries(e).map(([i,[l,c,h]])=>{const{pattern:u,params:w}=he(i),f={id:i,exec:d=>{const _=u.exec(d);if(_)return ge(_,w,r)},errors:[1,...h||[]].map(d=>t[d]),layouts:[0,...c||[]].map(s),leaf:o(l)};return f.errors.length=f.layouts.length=Math.max(f.errors.length,f.layouts.length),f});function o(i){const l=i<0;return l&&(i=~i),[l,t[i]]}function s(i){return i===void 0?i:[n.has(i),t[i]]}}function Ft(t,a=JSON.parse){try{return a(sessionStorage[t])}catch{}}function It(t,a,e=JSON.stringify){const r=e(a);try{sessionStorage[t]=r}catch{}}function _e(t){return t.filter(a=>a!=null)}function Et(t){return t instanceof wt||t instanceof yt?t.status:500}function we(t){return t instanceof yt?t.text:"Internal Error"}const ve=new Set(["icon","shortcut icon","apple-touch-icon"]),I=Ft(Kt)??{},M=Ft(qt)??{},P={url:Pt({}),page:Pt({}),navigating:ae(null),updated:ne()};function bt(t){I[t]=C()}function ye(t,a){let e=t+1;for(;I[e];)delete I[e],e+=1;for(e=a+1;M[e];)delete M[e],e+=1}function V(t,a=!1){return a?location.replace(t.href):location.href=t.href,new Promise(()=>{})}async function Bt(){if("serviceWorker"in navigator){const t=await navigator.serviceWorker.getRegistration(L||"/");t&&await t.update()}}function Tt(){}let kt,ht,Q,U,dt,b;const Z=[],tt=[];let v=null;function pt(){var t;(t=v==null?void 0:v.fork)==null||t.then(a=>a==null?void 0:a.discard()),v=null}const G=new Map,Mt=new Set,Ee=new Set,F=new Set;let m={branch:[],error:null,url:null},Vt=!1,et=!1,Ot=!0,H=!1,K=!1,Ht=!1,St=!1,Yt,E,R,O;const at=new Set,Ct=new Map;async function Fe(t,a,e){var o,s,i,l,c;(o=globalThis.__sveltekit_1rrld2f)!=null&&o.data&&globalThis.__sveltekit_1rrld2f.data,document.URL!==location.href&&(location.href=location.href),b=t,await((i=(s=t.hooks).init)==null?void 0:i.call(s)),kt=me(t),U=document.documentElement,dt=a,ht=t.nodes[0],Q=t.nodes[1],ht(),Q(),E=(l=history.state)==null?void 0:l[N],R=(c=history.state)==null?void 0:c[B],E||(E=R=Date.now(),history.replaceState({...history.state,[N]:E,[B]:R},""));const r=I[E];function n(){r&&(history.scrollRestoration="manual",scrollTo(r.x,r.y))}e?(n(),await Ce(dt,e)):(await D({type:"enter",url:mt(b.hash?Ne(new URL(location.href)):location.href),replace_state:!0}),n()),Oe()}function be(){Z.length=0,St=!1}function zt(t){tt.some(a=>a==null?void 0:a.snapshot)&&(M[t]=tt.map(a=>{var e;return(e=a==null?void 0:a.snapshot)==null?void 0:e.capture()}))}function Wt(t){var a;(a=M[t])==null||a.forEach((e,r)=>{var n,o;(o=(n=tt[r])==null?void 0:n.snapshot)==null||o.restore(e)})}function jt(){bt(E),It(Kt,I),zt(R),It(qt,M)}async function Gt(t,a,e,r){let n;a.invalidateAll&&pt(),await D({type:"goto",url:mt(t),keepfocus:a.keepFocus,noscroll:a.noScroll,replace_state:a.replaceState,state:a.state,redirect_count:e,nav_token:r,accept:()=>{a.invalidateAll&&(St=!0,n=[...Ct.keys()]),a.invalidate&&a.invalidate.forEach(Te)}}),a.invalidateAll&&J().then(J).then(()=>{Ct.forEach(({resource:o},s)=>{var i;n!=null&&n.includes(s)&&((i=o.refresh)==null||i.call(o))})})}async function ke(t){if(t.id!==(v==null?void 0:v.id)){pt();const a={};at.add(a),v={id:t.id,token:a,promise:Xt({...t,preload:a}).then(e=>(at.delete(a),e.type==="loaded"&&e.state.error&&pt(),e)),fork:null}}return v.promise}async function ct(t){var e;const a=(e=await ot(t,!1))==null?void 0:e.route;a&&await Promise.all([...a.layouts,a.leaf].filter(Boolean).map(r=>r[1]()))}async function Jt(t,a,e){var n;m=t.state;const r=document.querySelector("style[data-sveltekit]");if(r&&r.remove(),Object.assign(x,t.props.page),Yt=new b.root({target:a,props:{...t.props,stores:P,components:tt},hydrate:e,sync:!1}),await Promise.resolve(),Wt(R),e){const o={from:null,to:{params:m.params,route:{id:((n=m.route)==null?void 0:n.id)??null},url:new URL(location.href),scroll:I[E]??C()},willUnload:!1,type:"enter",complete:Promise.resolve()};F.forEach(s=>s(o))}et=!0}function nt({url:t,params:a,branch:e,status:r,error:n,route:o,form:s}){let i="never";if(L&&(t.pathname===L||t.pathname===L+"/"))i="always";else for(const f of e)(f==null?void 0:f.slash)!==void 0&&(i=f.slash);t.pathname=se(t.pathname,i),t.search=t.search;const l={type:"loaded",state:{url:t,params:a,branch:e,error:n,route:o},props:{constructors:_e(e).map(f=>f.node.component),page:At(x)}};s!==void 0&&(l.props.form=s);let c={},h=!x,u=0;for(let f=0;fi(new URL(s))))return!0;return!1}function xt(t,a){return(t==null?void 0:t.type)==="data"?t:(t==null?void 0:t.type)==="skip"?a??null:null}function xe(t,a){if(!t)return new Set(a.searchParams.keys());const e=new Set([...t.searchParams.keys(),...a.searchParams.keys()]);for(const r of e){const n=t.searchParams.getAll(r),o=a.searchParams.getAll(r);n.every(s=>o.includes(s))&&o.every(s=>n.includes(s))&&e.delete(r)}return e}function Le({error:t,url:a,route:e,params:r}){return{type:"loaded",state:{error:t,url:a,route:e,params:r,branch:[]},props:{page:At(x),constructors:[]}}}async function Xt({id:t,invalidating:a,url:e,params:r,route:n,preload:o}){if((v==null?void 0:v.id)===t)return at.delete(v.token),v.promise;const{errors:s,layouts:i,leaf:l}=n,c=[...i,l];s.forEach(g=>g==null?void 0:g().catch(()=>{})),c.forEach(g=>g==null?void 0:g[1]().catch(()=>{}));const h=m.url?t!==rt(m.url):!1,u=m.route?n.id!==m.route.id:!1,w=xe(m.url,e);let f=!1;const d=c.map(async(g,p)=>{var A;if(!g)return;const y=m.branch[p];return g[1]===(y==null?void 0:y.loader)&&!Re(f,u,h,w,(A=y.universal)==null?void 0:A.uses,r)?y:(f=!0,Rt({loader:g[1],url:e,params:r,route:n,parent:async()=>{var z;const T={};for(let j=0;j{});const _=[];for(let g=0;gPromise.resolve({}),server_data_node:xt(o)}),i={node:await Q(),loader:Q,universal:null,server:null,data:null};return nt({url:e,params:n,branch:[s,i],status:t,error:a,route:null})}catch(s){if(s instanceof vt)return Gt(new URL(s.location,location.href),{},0);throw s}}async function Ae(t){const a=t.href;if(G.has(a))return G.get(a);let e;try{const r=(async()=>{let n=await b.hooks.reroute({url:new URL(t),fetch:async(o,s)=>Se(o,s,t).promise})??t;if(typeof n=="string"){const o=new URL(t);b.hash?o.hash=n:o.pathname=n,n=o}return n})();G.set(a,r),e=await r}catch{G.delete(a);return}return e}async function ot(t,a){if(t&&!_t(t,L,b.hash)){const e=await Ae(t);if(!e)return;const r=Pe(e);for(const n of kt){const o=n.exec(r);if(o)return{id:rt(t),invalidating:a,route:n,params:oe(o),url:t}}}}function Pe(t){return ie(b.hash?t.hash.replace(/^#/,"").replace(/[?#].+/,""):t.pathname.slice(L.length))||"/"}function rt(t){return(b.hash?t.hash.replace(/^#/,""):t.pathname)+t.search}function Qt({url:t,type:a,intent:e,delta:r,event:n,scroll:o}){let s=!1;const i=Ut(m,e,t,a,o??null);r!==void 0&&(i.navigation.delta=r),n!==void 0&&(i.navigation.event=n);const l={...i.navigation,cancel:()=>{s=!0,i.reject(new Error("navigation cancelled"))}};return H||Mt.forEach(c=>c(l)),s?null:i}async function D({type:t,url:a,popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s={},redirect_count:i=0,nav_token:l={},accept:c=Tt,block:h=Tt,event:u}){var j;const w=O;O=l;const f=await ot(a,!1),d=t==="enter"?Ut(m,f,a,t):Qt({url:a,type:t,delta:e==null?void 0:e.delta,intent:f,scroll:e==null?void 0:e.scroll,event:u});if(!d){h(),O===l&&(O=w);return}const _=E,g=R;c(),H=!0,et&&d.navigation.type!=="enter"&&P.navigating.set(ft.current=d.navigation);let p=f&&await Xt(f);if(!p){if(_t(a,L,b.hash))return await V(a,o);p=await Zt(a,{id:null},await Y(new yt(404,"Not Found",`Not found: ${a.pathname}`),{url:a,params:{},route:{id:null}}),404,o)}if(a=(f==null?void 0:f.url)||a,O!==l)return d.reject(new Error("navigation aborted")),!1;if(p.type==="redirect"){if(i<20){await D({type:t,url:new URL(p.location,a),popped:e,keepfocus:r,noscroll:n,replace_state:o,state:s,redirect_count:i+1,nav_token:l}),d.fulfil(void 0);return}p=await Lt({status:500,error:await Y(new Error("Redirect loop"),{url:a,params:{},route:{id:null}}),url:a,route:{id:null}})}else p.props.page.status>=400&&await P.updated.check()&&(await Bt(),await V(a,o));if(be(),bt(_),zt(g),p.props.page.url.pathname!==a.pathname&&(a.pathname=p.props.page.url.pathname),s=e?e.state:s,!e){const k=o?0:1,W={[N]:E+=k,[B]:R+=k,[Nt]:s};(o?history.replaceState:history.pushState).call(history,W,"",a),o||ye(E,R)}const y=f&&(v==null?void 0:v.id)===f.id?v.fork:null;v=null,p.props.page.state=s;let S;if(et){const k=(await Promise.all(Array.from(Ee,$=>$(d.navigation)))).filter($=>typeof $=="function");if(k.length>0){let $=function(){k.forEach(st=>{F.delete(st)})};k.push($),k.forEach(st=>{F.add(st)})}m=p.state,p.props.page&&(p.props.page.url=a);const W=y&&await y;W?S=W.commit():(Yt.$set(p.props),fe(p.props.page),S=(j=ee)==null?void 0:j()),Ht=!0}else await Jt(p,dt,!1);const{activeElement:A}=document;await S,await J(),await J();let T=null;if(Ot){const k=e?e.scroll:n?C():null;k?scrollTo(k.x,k.y):(T=a.hash&&document.getElementById(te(a)))?T.scrollIntoView():scrollTo(0,0)}const z=document.activeElement!==A&&document.activeElement!==document.body;!r&&!z&&$e(a,!T),Ot=!0,p.props.page&&Object.assign(x,p.props.page),H=!1,t==="popstate"&&Wt(R),d.fulfil(void 0),d.navigation.to&&(d.navigation.to.scroll=C()),F.forEach(k=>k(d.navigation)),P.navigating.set(ft.current=null)}async function Zt(t,a,e,r,n){return t.origin===Dt&&t.pathname===location.pathname&&!Vt?await Lt({status:r,error:e,url:t,route:a}):await V(t,n)}function Ie(){let t,a={element:void 0,href:void 0},e;U.addEventListener("mousemove",i=>{const l=i.target;clearTimeout(t),t=setTimeout(()=>{o(l,q.hover)},20)});function r(i){i.defaultPrevented||o(i.composedPath()[0],q.tap)}U.addEventListener("mousedown",r),U.addEventListener("touchstart",r,{passive:!0});const n=new IntersectionObserver(i=>{for(const l of i)l.isIntersecting&&(ct(new URL(l.target.href)),n.unobserve(l.target))},{threshold:0});async function o(i,l){const c=$t(i,U),h=c===a.element&&(c==null?void 0:c.href)===a.href&&l>=e;if(!c||h)return;const{url:u,external:w,download:f}=ut(c,L,b.hash);if(w||f)return;const d=X(c),_=u&&rt(m.url)===rt(u);if(!(d.reload||_))if(l<=d.preload_data){a={element:c,href:c.href},e=q.tap;const g=await ot(u,!1);if(!g)return;ke(g)}else l<=d.preload_code&&(a={element:c,href:c.href},e=l,ct(u))}function s(){n.disconnect();for(const i of U.querySelectorAll("a")){const{url:l,external:c,download:h}=ut(i,L,b.hash);if(c||h)continue;const u=X(i);u.reload||(u.preload_code===q.viewport&&n.observe(i),u.preload_code===q.eager&&ct(l))}}F.add(s),s()}function Y(t,a){if(t instanceof wt)return t.body;const e=Et(t),r=we(t);return b.hooks.handleError({error:t,event:a,status:e,message:r})??{message:r}}function Be(t,a={}){return t=new URL(mt(t)),t.origin!==Dt?Promise.reject(new Error("goto: invalid URL")):Gt(t,a,0)}function Te(t){if(typeof t=="function")Z.push(t);else{const{href:a}=new URL(t,location.href);Z.push(e=>e.href===a)}}function Oe(){var a;history.scrollRestoration="manual",addEventListener("beforeunload",e=>{let r=!1;if(jt(),!H){const n=Ut(m,void 0,null,"leave"),o={...n.navigation,cancel:()=>{r=!0,n.reject(new Error("navigation cancelled"))}};Mt.forEach(s=>s(o))}r?(e.preventDefault(),e.returnValue=""):history.scrollRestoration="auto"}),addEventListener("visibilitychange",()=>{document.visibilityState==="hidden"&&jt()}),(a=navigator.connection)!=null&&a.saveData||Ie(),U.addEventListener("click",async e=>{if(e.button||e.which!==1||e.metaKey||e.ctrlKey||e.shiftKey||e.altKey||e.defaultPrevented)return;const r=$t(e.composedPath()[0],U);if(!r)return;const{url:n,external:o,target:s,download:i}=ut(r,L,b.hash);if(!n)return;if(s==="_parent"||s==="_top"){if(window.parent!==window)return}else if(s&&s!=="_self")return;const l=X(r);if(!(r instanceof SVGAElement)&&n.protocol!==location.protocol&&!(n.protocol==="https:"||n.protocol==="http:")||i)return;const[h,u]=(b.hash?n.hash.replace(/^#/,""):n.href).split("#"),w=h===it(location);if(o||l.reload&&(!w||!u)){Qt({url:n,type:"link",event:e})?H=!0:e.preventDefault();return}if(u!==void 0&&w){const[,f]=m.url.href.split("#");if(f===u){if(e.preventDefault(),u===""||u==="top"&&r.ownerDocument.getElementById("top")===null)scrollTo({top:0});else{const d=r.ownerDocument.getElementById(decodeURIComponent(u));d&&(d.scrollIntoView(),d.focus())}return}if(K=!0,bt(E),t(n),!l.replace_state)return;K=!1}e.preventDefault(),await new Promise(f=>{requestAnimationFrame(()=>{setTimeout(f,0)}),setTimeout(f,100)}),await D({type:"link",url:n,keepfocus:l.keepfocus,noscroll:l.noscroll,replace_state:l.replace_state??n.href===location.href,event:e})}),U.addEventListener("submit",e=>{if(e.defaultPrevented)return;const r=HTMLFormElement.prototype.cloneNode.call(e.target),n=e.submitter;if(((n==null?void 0:n.formTarget)||r.target)==="_blank"||((n==null?void 0:n.formMethod)||r.method)!=="get")return;const i=new URL((n==null?void 0:n.hasAttribute("formaction"))&&(n==null?void 0:n.formAction)||r.action);if(_t(i,L,!1))return;const l=e.target,c=X(l);if(c.reload)return;e.preventDefault(),e.stopPropagation();const h=new FormData(l,n);i.search=new URLSearchParams(h).toString(),D({type:"form",url:i,keepfocus:c.keepfocus,noscroll:c.noscroll,replace_state:c.replace_state??i.href===location.href,event:e})}),addEventListener("popstate",async e=>{var r;if(!gt){if((r=e.state)!=null&&r[N]){const n=e.state[N];if(O={},n===E)return;const o=I[n],s=e.state[Nt]??{},i=new URL(e.state[re]??location.href),l=e.state[B],c=m.url?it(location)===it(m.url):!1;if(l===R&&(Ht||c)){s!==x.state&&(x.state=s),t(i),I[E]=C(),o&&scrollTo(o.x,o.y),E=n;return}const u=n-E;await D({type:"popstate",url:i,popped:{state:s,scroll:o,delta:u},accept:()=>{E=n,R=l},block:()=>{history.go(-u)},nav_token:O,event:e})}else if(!K){const n=new URL(location.href);t(n),b.hash&&location.reload()}}}),addEventListener("hashchange",()=>{K&&(K=!1,history.replaceState({...history.state,[N]:++E,[B]:R},"",location.href))});for(const e of document.querySelectorAll("link"))ve.has(e.rel)&&(e.href=e.href);addEventListener("pageshow",e=>{e.persisted&&P.navigating.set(ft.current=null)});function t(e){m.url=x.url=e,P.page.set(At(x)),P.page.notify()}}async function Ce(t,{status:a=200,error:e,node_ids:r,params:n,route:o,server_route:s,data:i,form:l}){Vt=!0;const c=new URL(location.href);let h;({params:n={},route:o={id:null}}=await ot(c,!1)||{}),h=kt.find(({id:f})=>f===o.id);let u,w=!0;try{const f=r.map(async(_,g)=>{const p=i[g];return p!=null&&p.uses&&(p.uses=je(p.uses)),Rt({loader:b.nodes[_],url:c,params:n,route:o,parent:async()=>{const y={};for(let S=0;S{const i=history.state;gt=!0,location.replace(new URL(`#${r}`,location.href)),history.replaceState(i,"",t),a&&scrollTo(o,s),gt=!1})}else{const o=document.body,s=o.getAttribute("tabindex");o.tabIndex=-1,o.focus({preventScroll:!0,focusVisible:!1}),s!==null?o.setAttribute("tabindex",s):o.removeAttribute("tabindex")}const n=getSelection();if(n&&n.type!=="None"){const o=[];for(let s=0;s{if(n.rangeCount===o.length){for(let s=0;s{o=u,s=w});return i.catch(()=>{}),{navigation:{from:{params:t.params,route:{id:((c=t.route)==null?void 0:c.id)??null},url:t.url,scroll:C()},to:e&&{params:(a==null?void 0:a.params)??null,route:{id:((h=a==null?void 0:a.route)==null?void 0:h.id)??null},url:e,scroll:n},willUnload:!a,type:r,complete:i},fulfil:o,reject:s}}function At(t){return{data:t.data,error:t.error,form:t.form,params:t.params,route:t.route,state:t.state,status:t.status,url:t.url}}function Ne(t){const a=new URL(t);return a.hash=decodeURIComponent(t.hash),a}function te(t){let a;if(b.hash){const[,,e]=t.hash.split("#",3);a=e??""}else a=t.hash.slice(1);return decodeURIComponent(a)}export{Fe as a,Be as g,P as s}; diff --git a/apps/dashboard/build/_app/immutable/chunks/C2TQQEIa.js.br b/apps/dashboard/build/_app/immutable/chunks/C2TQQEIa.js.br new file mode 100644 index 0000000000000000000000000000000000000000..dfd5c89cf47482d037583ee6fe2617042579a839 GIT binary patch literal 7642 zcmV<09VOx$;8OrB3QRX8_a0;FG>%K>yp*PWA|j565t7W_+gjg!E~gLA1DREOW=^|) zx1H|&K$oFHA~C^AA=3Dtzx4h3HHx3++(yBs(=T~0yk*%jc2$sV8X~9=*?_|T?>9_c zdHct1z~8|XX!wsYFO1f2pZquP7a9+f=%HN=@9b&YAsd!w`zYRIMBSU zjpL0~^bU!jqt?!+AI4ex_okZdVo6FmR~&T?sdnXY(NGZOSh^@(RPKoP{(CF#-(c+` z%wZRR2Oyw8Wl%gR|NTpP7E5{tR63AHk4ZTtl6Sevx$B)mYp88V@XC;Fft}y`VZN{b zXuIzIF?u5)U~038N_>&Aw}AJHB~Qn%I_4b9JBs7#$(tYLkC&Z~&+kQeHya^Hg6mTn>I`b?{EtR#xg_^vuGjO$c9^$F{Lb zFUHo~e}+<_;Z1D>(|=}cb&jqqgC0y}jjMSvta&x0$)8zS)yCeu`Kp{>^Ynu|>c?CE z1LE*jo$+J6=Z#tJZpF+$Kc zS=7m^9kw|QY~w#+<125rdCl}c;P!}uv0QBccY#hYGL9Z7FQzZKW7qmPn#C+uB3tdY ztK~|&ym{r+7vXca9J}ic$E)u;kkXirIr*JD6WZ&HX0kuF|JV|QC@T)t>;iuTJ+4o? zIhgkEW7Y%Xf$>;dM~R4`qocLB?U=3dV-&{7^l!*_#RX!BO>V~h3VBYnx5N8Gd=Wpf zo<LhYJqui66bx@zFE>xqNiE^2>JSf zugf;jFr28ov+?aVPyu3VfUg~QE?Sd4oQOON7fO5LOrHA#4z2+a;}H%czs7M~OcKf$ z0uqeOO3}#@aw+lTC7D3vdW7bClfUP_3~7=VdC_L@o)5O93bPKOJNwFK!Q zfJw9HC3Hd7`?s3bavPU~ZbYZ-R!;##zb+XX1(L{{9R(;21s4G4Ql&zuqAoMHn-s>2 z%ogUXjo-STqwKfEE5R9rs78JF%24yJwT248N&H%UZy~ste>2aw#XKDuZ?{V+cG?ei ztb4Fu{U~o&m+g?EXcrR_kS~w|2WTf%W+<5-)@sv^4`8AI!<=3*G$&P z-m_U-dJW{_sv5iUxn5I2B!H5fOEUmiJZb^r?qeV@;H%~}KN?EvH6bzDrpGqxdq2^u zZ3DIbuTf`{JdM&^b_hp)ebW=K8t3i9h5pV5g;GBIrv?+m{2)?4OBvqXMO1;#O4G47 zyE!kOj4wNWj4d`GiiJ|}m~CMIqSnWFhweWIGxW*m#(?_s=NVS1@Hsf?S8UR>dwWjXmM5sthV`^XFD zH=nrBb7N&1**Lp#n7F>lUgPkt(R-ttaqPh#%Cismxub?eUAT^!cF-;%3Vh_LX6#p0 zJp82Bm~075fJFWCsIV2eSoqgs;tC;_1&29t%l;W>!3=CX?b|4E+s_}z6(xX~T_OcH9`r(`EPemx8 zE@_wDa}Sar=+Relid~;RT1R0JTrYu}#z!A{QXo`ZgrpXFi2ZAv?PX8L`cVgJAKRQ( zoc9XA(tMR*_@o^01_{AlOyy=nZ4NT#4Bnd(Rgf8*(?A$Jo z&gqwva*nQ=T;iENYkpIyx;GGp9i)U(QuLR7&D@xF`qz>&=$l}U<>BM+$H`fL35?>mprpVuf+*!lC;zfR;*&uis zO6lFT9Ui6=f1RR5;vG5;f;kEBkHGIDQQss`;Way5{I9VxDvJEdmkdF~$6yqsXdx8a z;1@WNm1h!5LI&!NzRx`;I0fgl(#p6@a8z#l|A}Q3QOO(Ut401}OyGj7U85H8%Q!k2 z*Zd7KcV`SknM8~hxdCAwLPPse9|we)XTu*qo}vAyGZYQt%k&E%w$10Uawlk&1~bR8 zFS<4#1aNoN4gz(TWPd_@8)ziFa{n3$%R~{X)HF(;?GRru<)uz}9LG-v7~8}|-)kf; zR^#mbF{ujUjbC>`4cz6|nEcQax2iY3Jj9+aLjyO>aM;pwr$opOz*tAE)B%)4ly{YIx9fQcBEg8Z{om8 zu-wp4#XX8Tuo}U4Kui)>5*9Oy_2HZKJCoz^3kQp;SYV$sB~I5QsVQp4*o8xW4fc!d*f+{v|6@A{bQ zjLA0wZlBKck<$sjMcYMPubWMTanwJL*wCJ@pYcuDv-;o4n_xAvctTdAsWH;ubRc}e z8J5_?@F0p3Y)O|--Hrdsm)MZ132Y5mrxQ3`HHjXL&6|Tp1_^?2FfxYO zR&Nk~a}c>cN~Ajc`XBY>XjM#mW+y29*`a`iQpXyRGx&R-zoT&UTiILNP-k7+~#1We4h+WPJmyhw8gU zMflzHCz3AVpp*AxBc0(sb8$u)$XZyBH@wXtR$y}Ozl3_1R3+M)@Cx`;xp}YGnH3;( zl+rislOIDOjh~F+E_YN#D3II0JJfH3dq~2bd7RaXZdpsw3aX~=qj(R8@8wHmmmkBS z%sEt>aB7jglkEjYs!!1xb0Hk`yJICA5qM-)7beI*onLf6 zjzc{wdI{?s5&r8#bQSfxkp)0~6ouXJ9#38&(9&d`yR0bKmbbsUlP9FdNTSMPBXRR3 z`ejaArmXLc-1hzq^vV8NVLU_-TNQ1A*86e07kops=+Zbkot{$w)1-9)Bla+Z6XZDw z7Sh$6UC`1 zd>C!wY|lBFRdxX!{gQC$;@iyGG^ITvu@NX(*$iu40FO=d8zp#m8xT$j(DpN|u1?M+ zvecj|lw$TW)52ssQ9l9@My90t+Nj&Sn^&xuwZ1||`F z)wISFDtsdN3n4Sroc#DfJUGLEDyl>NCCxkF*YtRXCpBkM21VSu=>C3+43BIBf?j5K z7;Y_tz$*-VWzkEKX?GX<;#q#UO5kiWSUtv?@UmnK#J?0o=v5n~Q{&}C;8SE|kz<9# z4oI27TW%q0;}wSiJ_k9Qtlbe+^MJtc(BA2Tj#g&|17)lrZ|hmCkxah;0(TVr`$53( z7;%1|t?noXZYA1U5jZ)c$a$M~RCKX!M;23V8f6e<@O8ggmn8`CHCcZi_J)Hb>cK2+ zIlD$&gKmGk3| z8fOlza6WauSL4j`Xa+UiM<(~AcEfz0WgN~I;p39u;jy@b#do8a{YhLAH4!<*efnA= zvMtc?NP)ia}l z>BzIuM7Pu#-Qaiy3Pl4)Iy+2wM#ro?3NM+F(CDf4+!2u~$0SB~hv9B{N)*gg0Fml& zAHAg@MK@zU-n#EF%yCP{@^qyM7!FB1Vs+hiRFg@ogX;9$yMfG5pDA0^P>tG}V2bmz z)GMbq`mk+seNI#`*Dk;;?oJW+_)nY~>W13S~xP#Io3 zn&Vc}R(2!7*@~hdA03V} z3`*a7G3&$*QR}Nn>NeWf3Ac}+7i%Q}kKN56lifTDjp`(GxaS>8o~#szOVr2GpkSZd z^G8p!{D}_{52K5*aM*w{T8sI!5Ja95o&5E?**?KP`}SrLT4r!)Z6-rF=}DuW^h0{7XmBexT4aa;+l(yah)fHo zI7JGjMC*o*LEc|(VR!Q~kVTG8Z8Z*B63@=Q#Q{KqqD0nmXJ!&jYETZY7fl+Tx!qIT zi1tq9HFM)pPB{&%aU}Ca>@K8_2_!|P8!lbeRP#7MNxzK@2G7Re#6RbJ!sGiBX}zaH12##Tx3o5;(#t1(yUz`iT7 z`3E5#lFS-#=_Qdy8mPlB`!6@oNe*2vo67`7>}`y`85bg%KtGgOPeJmuOgxb|#{T=U zht3-&Ji-p|>*6@}HK5MThR{yfJ-bygvF0S~&3O8fGjW*l#UmSA2`KEcWq$cizwk0r z>C0|`VK|m+;FPs9JZ^Z#>g+mOX}n}eCzIz?F=fxk1B1p{^)hO-zS-6n{hpWlYW4ce zZM`Yl#H}Sc?zxs0HTp1i`kqk|eG@JT85RAsT_I00_}36~)4&JaU8x#f)M9$Iu;7 zP(}Gvb`5Y~fomI;4$2D{n>i|Hf`L4qg$}qz$7bF7+<_iZiFYx9YzBzsLYRB0*7#$) zV*LIL>+P%yKetVV_SaTV?9R`~S|_|R+|5jyU<3k;vhGnFVZJ2RIDWc$pA2`;!%fD2 zjJy}j!}qNZS4WYJU#XZZMj5MR59a=`k^0C%7F;S^^iM?rdV>D`EnEGy3iD8ZHix?5 z3f;L;h#O)Hr$PDlL`Artr#HgW;V-`lgfIO*!K-E~*)W+{JuzwjYugsM_l*|`#$5my zf+OhO=RFyjF4-s&i9mZ>094uvG(pUk!|FKPO=OVWKT-95B+q%NQtiIAfiD^j9^x&R z-*Dpx?;VdbR3z$R7?5sJ>=giM_!BkX~!<&tJq~``4)jj^Ku6&6iLsM(px5|b(HeYlH zdAGFVWq<2OtZ3-fAX@Uvaj(x11+a_B=$<2)3jfL~6FcWFFne;=FfY>RTN)K}4KYcX z#55uLH}0$rOHJ!+LRC_R9_nHXTTVWv2^E{!H6KDMV-8SG3Miv-YLPl0|#MqVS`}e!h!A{EI}s5#2YImi8K7 z(UwftqFPn-p%vPlA;FHivjd1&EK*~vMTt35$p@VhxKi=KDsl)lwnmxvu@|gXqKfUM zA3P7eTSK5)uUcA*?N2Sy&obFiaoB^S@6OP-vRw?1KR*3sF|PPW}FARJE6w=JyVp15o9cO6w`Vc`uh+)DL@R=2olhpxnKt~}a& zCACaw-AgkDX}JbCyCRcAC)4g=@F~pu5P>@?XEU}uqk5vt0$tRPHco5*ix6cOe)hIM z^9Ya~?dY%94J{`41X9b;4WFP^DP|L`3aRUC{KPNxD9jt<=EFYCVtaXc8XO|ouhu+$ z3Dt&YKVc_TeJ~^=2(cV(bm-x=7rB0R2{RrVGHlu9*-p(=#;8J)|K-U&amL>NsY1Gs zB9dWBD3uaGsU)Q()%=uVrr_euS|if#mWhHNNu~ocGdC^4XT71!wAzPegU-0ff9YqP z4qyarnw%%I8_?_Q5Stf})jP#bkz=}u!S-Ph7Zv%IT0gr%)RnjvL&18?{NFm_!OV*x z?Xe8>{Z9DZ(RxW~SWrc0x5CiNo_UiwBqT%o8$#?XeL&m$j-;EP&7p>op!imGhmkj0&-d#U0?HinbPoGuz z{i-FOTB+ZGWk{o@&J*HX!P9~%uHtFzmkF3_%oHKZ+ySl&f|$krXDs%~DGp~hhNfxs z!b=>5-6#ryxgj1fI)dM@f)`D>&RG5IL|6tqg6gK9&4vu9O{kD(>nAMz*?o&7f(v9b zamIumBc7&RlRBosIwy;A&3bha<8&_S^*qnhIJ?kBCovPwmXNkKE*lj8suDyum(c)H z1~u;NcmXtoJwbL2BB2#p2g=0c!)z@{bZ`3o*8FF+48N2dVs-!}$)UN@dZw&r+J@8g zHMDEANdKY}mUPf0Y<;IQC_W7^X1fuxJcvA*kyuWAL7s%H_3gMgwe;;8M78BtgPEH7 zb2(<2jA^g%mM~E-)o;S62`LOWG)!*EuS($2T4IXQtP&j&qVverSM7=i=nyP$`mrEw zUI%pz2iq+vQ{uM9)>mamH5=QC6scJP6EU+yM_a$(P^$pbeSMhPDj}}hkGzojE<({4c*Knm$6SKhD>m;JA+9KV@+Pdbw zT=z_lM>VB{5$?>W?OdGrWkAWTv%3anQa=>EX__V2AWdl+1Ksfe=Za zul=S0wEiQT;x_!#`Ax&e>kN8KwAf1hkWirX4*W@#w~ZwL%t0dn*OoR7=7aB!!U5+7 z0T0<&p!H8!Nu*M$q-ByjBDjTo`&DeY7nwq6wA=G=ea`L-_2CZUa`t!t_>O!*@F zG|s4X>GQQ}C%#XqqNk__4bd_3dd(&qioL<8k~f_@n5jbSK3A!pg@K$`;TYMOx5W}{ zH2B~ATtgVTxu+SOPG;_wFDoqN!ioXa(5;YukMv%Q)M&+ZQq5Fj*EWqdtblKCpG!GF z+Q6E|(GHTMQiub8o0#7zDjuB zq?@=Sq;ST7=4T(K=fEqzpmogfFZqBCV>rd;0nS#ePZ3qa*+PiI-Mz*iJcMGf2{_aF zDt?phun(~RcRXSQv>v3UMxY)K=$#{UTmOMf>;vAoFdTZkt;=6)>DUqxME5B zVQwy}Fp?qIS@pOcAJr8d^)ZRHj`5w{=$Goja$z}*_oewl+msAs$7>3kuk4cs4BBh*te0f2 zfQVbj@wK3|0mow%sv@ZZ$vTB5A6urSPHZT3sAgkuYx=30QL-_SxTJ}8B<~#|A;K{R z7?NNbB7Ct_Ywl-UJ)rXImDKM9$nH%Dbv=9IEhGPr%!Kl|7+RnC%Whz771OEC-U|4U$Pe$%_0#N$s~V)*EjqPUY_s*FLT8c zyp9#W#_KCy;^iq{;N_lYc$p|Z!RvwIQ@kz}5Apg7r|~6U z!>J5p70AYW8SE(Y<)SF^BG@}vht-#=Qu!6N=dpDm)w0O;e!P17#@C%Bla=S1U{$3@ zd;8a;#iulnLY3s1khbDV?a6y3v$))&L3Eqp1zVTPg)F>+@f|HHs7}@ zhiu?|_VFLy+#NA*5D2=#=Mftm9QP;7EW)Ae&7`N8?shK}!%<()dA$ggl0_CM0R%qo z4UT{Re0*>mWb$tBQcf@K7v7iO57rB;?a#x7SBNvyN(O`YJk$f|cK>;FaO}%_8Nqz| z$;8W;A#vz0mgUS_XW?81+3F#kHkB(>{(Dr^|8aJaV zMd6o=G*R9$49!0pu+JlJun!A!%nbE`;728q)k}HAfV9v~^tbOBUQ^_OLY1EqHS>D+ zM?Gc-pDItYu8$k*=`1Xs=CSk^VNuGLnZlZB5=rlS#!vs7F`9Y1wdG&8=KFr#j+sdB zQBQNhSe&`u#<~+`raco&sY#wPKIBV&$0s}$Pr=2M1pm zhe?I=G6<{6ZJd}kj%h*dW5PqK7sq>apLdMu)`y246fylnL7p6)y0Op1+02p< zro^Fp#&MO*n5a!`h($oPzD!HG2P05Pwv@DEQs1opW+R90VdO;&hzBo_MMffWoCU)^ zf~~s5LBmad1}iZ$L!J4Se-00qI0H8skH)o+h2g{7>#s6W{*7FfAQTLFV9dF>HRbzu zpcT!cZre2s68q?=E~Xb7OYfIv7K|>{O5kWuSN|i(6TY(>#n}kMKC5B4M!#q}|44P*lt*2-G51QhA{jczcHWG6RVt zOHXQX;tdl%1PRDzqY<+T#;K;I-IjNi05z5{J`w9A4ib)HCWxIz8jGctJTZy9v0Vn( zR$~xD1*^D3?OO)JQx5WNw%H6vBN_oTqK5H^@ibiJO9drPutZdsDB+t7Cqa%f#7<}8 z>jo_wO?*?|zIYv~8C1XbIwg6xBuuJewYtt>nr^oyk56oez<{vv{}*Tg^ir^kNA*&b zSjUu0+%6m>!7%e@A$~PA>MG9_3LHVehXgv{nPO!d3B3}a6O_9Gm;wlDs79=caG}?Y zHeM<%v_u;|)iO-t`eU*d@6=|~ zda+UiWiVCnualFyjXU{J8&m~>SI`4B2aFh|8oc!k47-(%!H2yB-t~B|oB?o;me7!X z4i}45K2rHInmwXdz+x{2ko_mc1_O}pukqmz^YBirmqi-9Q{K8lWdxwr+-Ko!G6hhX zO@mN+L*hw1Y&k8wVf%|}uLcirm#CHHal2Upe zZvTo^VY$kpJ=ez*7V(co!zB{@}Oj_*1C>*e1ZI zG!pOCW`oMB4=O}gRK6xG(5{~3dmKQ8q`OgkrufhN1CPP>GOFn}K-63*#MM~lmN>Ou zk_Fbj4U0Y1_msF5^m(B7XK?ESt#6oq32f`Dnaqgc+vP$(PRb}OVvjMddoYan1M%VO zaKT?I%aZ)UaVLLn?`UvyvA!;V$7cbInS@e+ZE@s0YLtIeu$)}d-?#AhgulSspYYEM zdV58Ge}!K7C4Xy(5Z0YPRdz`I&PqOa5C`dzb3havB!Az_#Wc;Y!}LAcJL7SAD`Df` zBx-zG6lwhZgz4>nc$oXJI^p5rw~JFD9_P_=4$8*=aQOzHkNg;l*ZYQ|<`9Qp_@IJ6O5Rvf^xh5ChfIlLIvY@VSh4PY#F9Ku0Orcy~4leg}-8~k^>JK&?Mh`Dm~aaA?b%4>L9|7Ml=iRSnE^PePQ6=;+k z)_T`gEwgX|xYDP#94JlqJTOMxmpOeXwr(g9IL1Kph+?YmD_14F($x`_Ml2 z=7dRzvgIO-W}b&W2Ge=QbKGwpSQctnj5_^f-2rSiIbrM^x&~{d(e+o9YoKo~K&hch z<1ZNp+Fa7(ABw-;668M^uz(H^6h>J;g#C02P#8t-Iqq*1mb|m*(_H0l&0%ldNV%B6 zrUDr1!A-S0p7fF@(MI)EE~GRDH7~=$FQmTbTDi(yCpO+WZkL1JVRPnk#h;jk^^E zeOun$poVWIfg4afqFBywnlX23|Dq*y>18|f#y|y z5`zTwwv<;AgRzEdX0-s=to=~=VH^YQ14V^U9cyz<%8)O#t`B}uBx@ABkZ4nY*=?pO z#hC|9Xv~4FNFVtCt$r*hV=%#`UNsG?4cCCY;HXTs9ADkn|vVwn+Y?YHG-= zKNlLgN+)%lUio7wi`5lSiTsGYQms-sM8)^W=|ivq(G~&<6|nU4{1(IqH&$2(aD1A1 z_go=`7Nw7flYv?%<$Vn^1tP3fSO8|y>$WHZS~6XplT0XscRb4Hi#&rNftjc(K3l~F z?kw10Fg5L`X;TYXH>I(BB6;Cl9=TYf8%jeGl?Q8M`^|lQ!-@O>GL;7cY_6AMON0Se z4h9;{5U$y&9E=tUP>T%)2$uO>lBORr;zj^CEscY7M1Bmm=1}#YyIom|vywIw!l#Cv zkpU%fB+B`ixItlB41p*sEE+R&%#oMpL0M^0nTTE{!Tu&^<15(CunJ&ZqK^bN#w$dQ z&F3RTwG1kS>0P)gjr#>*y(aWz554Nlo3u$c@yir6Ds!GCGC1wqexr|4Hb%hFxCEpf z7ST-Do4z$*jTAR~*NEK*$z8#X5Fir z;hTF?F~je=ILB!Pvq2Qx>q#@7c17hSY${@^LNgL9J&Xn$m3DB28C+()S41sj7vL-{ zVk15?-cz#L^g1SD9m|ExVwpt=$T(}+m}VP~*eQl9s2jM!?%|@hz_?w$;;B(Ds4z_k zh6a;zHxWHh*#65bftxZ+1K@$wcaP2#ihQgzFxv}f*3)Dw`LcvTCsk0B66m_UI>c>; z;Izd-s?J({wQJ0Lu$z-K$);B%5O%exMMcASzH&AnlDQBqH_N32Emoqhh2%lM={rQW z0IA6OnV%QQG|51)NplNaSqLr2jeFXDvHOy_@Q_r4R6?CX2+$-%? zG6F}nxj_+dV~E^{JqG}xA1+efB#Yi4)cmMHT-}dxUm>wA?f0C6*--5rP1@jZyZ#L~ z9buOpML7Yt9Un%lLA64wOy}P2GzBOLkUK_ja}hr92{;*b_zH1C-h}529UJab*7+nY z7A~x0-;*_IUV+iBWwIjaV+C?81S`8fyEXB*D|6>Aa;msiue_y|p-9yg(g^d>1mMoV zAur}bV%i!5D4k)gcN!ePD~<(fJK@$R3j=Hp3-~nytc}yZbk6-myYkaYWIQ6H4c?6U zr9*L3aW-xDI|Xx$eAU)P2{ZpzaRT?98ZM4SN_c?5#6o%Wz({jgI6KI+wPhaR0YBdf z*aK7=MWRM1AZ{$~h_r(NiSJGM!rFu9B%Y@2*z~G~CkvYju!my?%6hBzR93#$Ou&Zw zAP6UX$!GkId*@>Hpqe=MQU8FEKUf6-(7-lssA}xz!PPfPoMvIC@TVE|do(RAI{OOf z?Cax2|0}|swn6irdw&`=8xOyB{TqL3rDtdTzS>3xAk(J9laW=dB$kXSrT1GDGAi4| zJ<&bWlp9l&8!?-<*`aTPR>P5-)D$K)eH_`K?G)#RDFMUjh+za}tYhbPZc`hN@fNgM z7EQ%^YqyA*g>`TAxV3_Ug-cbbkV{}Ip{B`QYCtVmbdSG!3%+)1rkAkBe#o@w%GkZM zm1fzMxKJ=!e%0@e_fD}Zv7m$-vQ=kfh-R8uXB*qM+V0_z*uK6$IcfUz?Y1Id9Xj(E73-GY;e$hI6c9N+ONZfFpvA7I6CFDg*2+w)5IoViOlxLCyhwgcI%k{goC@< zePd#SF2cU0SzZA>%)FJEb=X?xW-J;+2Tmf_ARmWq({%J88v<&k+B|Gc(ZY%++`(Nh z07mI{36dOS0S9ZML64tnV*K2hb&DWGB%;NG9FRHXT=HbZx2RzlKrgr!6(xy^a;K<3 z|EvRkPB`$6+XU7Pm{QG({BEz@T9xxwrkOT8akKwG!XxquU8!*>jtX+Jcko(6MI-0sKw2&973|C! zjJ|6I)DvkVG^AQ)b?V9Q-yLHpsga8^_-^DM(aWIrD;Wv<%Gq=jt*v`28YuvO(N&{W zc4VP@-O|s_K}YH`gy}0uVE|Y-*oR<;-r{p+y@t8*%at_?IQK6~6{qbQ8?*RcyYcO3f+mf{kOupaVE7lKSXanj|FAA zYM<_amTLlwrC4AYK&KqT%=Eg;uK%B2Tke=xZrCcO-`9hrJsPw14E^sg1PmL!6?aY= zSTuOSr{b~?!ViP)pv*x8#7&04!R@;l93H;&>)a3$KNICg%L4V3Xjas6b|EGr_CnhZ!x@Y2OWQV2ZYyop@{#v zcGoOic*%ieB1!W2`xCZq$0AkBX;~v^kl6p9g_I>Bexe@u`Bsk@t#F~;F zj>L`5cc7a$Y7~@J-^&NP5+(xs5+OUiVLGI0-t$kOeULly&1NON3w~*hjumdkha4Oe zxDIq~5YfD^Q-1gs$)zZ1Ym-GKRXrtdJ3x6}6yb{UyuAy_55(Dl*OC$NpAA>SM}v_L zU|(3lucL`KMjfA>Xcc%M?01i?Z|Yc>0+saK0-sW0e7S$4O`8M8w+dp&SeKf^BI=-g zbGksR?%ImbYQ|4uWw~zE|1`J~pD-RYPk_$??^op?plmeN5h}Kt0((?=Uxn-j62D?< z$P0?(5x?v9e}slG`wR4m@i2uj`CDnydxG=Ig=qV_#+709A05-f9j)4XZI1v^-!_(x zxYS4u3`}YcxEZ*#nH&Ee=(mEYy@!2(5*yTn4GROVHbZ%`dKr5JIvE?hH%-3GRQ@rM zchIbB?*tIN;mSYj_;PDnu;b1fopiss4`jga7l2&t*Dlr3SI~^_VibLMkkU20)=Z%>9YOp2BZ9rIRm~Dh`=-daGd6_lRab9B95;7GgWUi&*MolA* zW|+CJxa@zx-FAWCv8!;H8; zpxXtj9vo<#-(@{CwRV-Dj9WVK0!7dZ1Uz=D^SxRTCd%wBB@OWHwKl#n{;{sjrWDPl zgr$B`)}^y424-txIW;sgS!X=+mszgcbKd}N^EFt_vYh2<9N;V3&M3<^&oYFM zP3t*9Hu%s^xxtuDFYH;PoJgD2q>XCQ&WN;0o3ykx?m&z=+Xuu=SbymV=q+250y_WU z--7hU6QY>nWw|T?sJ2~Ff+z)19O20)u=b3O1t8SScKo&WH*_4bPMDEUx1I;eyXS?V z+<9w2TIb9x%;HpPyy*f<+6oG-e@b$DCbK|?%({N62la&9kzoGSBGox&CaH;YhCX{W_;x;Lh>m*IoDgrK?f*PZtJ7iLSCzy`VVwS|Q%m7#*rJzxe81=yc zBL)x_*o=$NFM(XoK!R;HsBU*EpD0bD8(1t7?oyxXl>YTnsXW_kq<=R{q8TvlDL%}l z3V)I-yp2?mn%i=gOq96~Q+wA{on4O~C=9tnlYU@3&ZlbUX)UaBZW8^+AZGOZ1kf-+Y%>zmt@eE$%TLk>t|D4OKogJCmi+0rA#Ni_MB1>hlNop zMN>Fkef;6vfKP^E5RjwFqdaY9`P+8@ue|z+mR+eu8T2q8qx(AOvCSrFjbb?C%aO3| z#q0t1qS^8GjOTZ-r|txvEQBXJB<*S4Y*HiMK}GF@g53u-w6^}I%%mNrNd`=$B`5l= z(H#_QZ=QaA@Nn7iBHo!jKjf29Bk8L#Ivfg$qb1Y)xwR{objo(Kp)0N_=8ytw$l}=p zmIjqVC_p&b85e7KO>n0coB$&JqODk>68muZ@~O@0LuK8M3EOuK8MFw{-QqFUIEeWZ z$}F9p4k8N#Vd}R$Fm{pgU`w@w0OlZ3<9N~pC817OI?s|ht?Bau5WI%J4LCeO&4Ll3 z#+%aOuJu}~SsqiZxxPiw0<}AWC2=ZyyB*ly=SmgHH3pe_*lK7n0Q#?X zc6+YX1a_;->Jz9M@?jQvN2*zJ@CXE4s?ng43AX4?Jqdbn0n7*%vOc|5=ak@da3xST zffa@Wu=%)VrdN%OByYz2`Ufz$V@8~dX2zt!jL|M;j2>dfsLPDWUo+!2D>|dUp+^xX z71{vMK+P+Jae_GwT@2rhYP@50xEj%c%$iH=mqNmq zPCPVq^`4AiL3MUdQ|fCa;1Yf4usyuH1a5kvHXA(du2XKQ6?l7ZJ$op*0NG=PI{Gen z4!Y8c)!e`5xxd0wVp%(iuoT&&i+)GW)CASbYn;_<>kYMGEfe=xR;@EH&tlu^k*Q)vbpV|k*xAXD)B&Dy7JF9Vs6t@K)$K1&%Sh|JxegXp0 zS;hb0c-zrY4s{udZU&-GYXED^IoIPgWWVym0x?x)}{HJJqSvOQD z>Z}q;*&X8~E_F6UGd&`=`49TB)cFgEPCiM&j>B`MCw=SPcz_4ce3|t@lWJZrZrcO*>*^AkbzL z6R3s1B8yNG>;hC%*=rSo3Sz>SwHDytgNjQ)H2fKp@bEO zk(b-yvI~rYb^>M-zTUlNCL9(up7l=zJk2Q_3~(74?6g|8qZZ5Un9bS&!5`7FrTAU* zTxBDNV&^dgZ##*)mCHRC3`eYUR$)gSlQ!;3(@}FzX?iVoUO@yu;4*ABElX#b?nfO+T~+z?#^gjUSyH_4>651KYeA(YLY zDIN}=6wbYO54(01loe{?e%JMFVP#9V^rsZ|*!n#L%d%g-J6IRhmoC5V)?5jyCRmHG zi2*o31frDDv@W@)6^{XElT#9U4Qo|+4U$sc1BG$`qt`F-K|DGINTEr!Ht$(a3 zZ0a{Yx+m+S$?VdlDa{J~#uaPkdwpm`zcd

      nH7Q6%edaW&xDI)O2+}@SkVEw%oU5k7K-i`94`3JvygulswJdpM z=X^I24e?B7iaB`f(n?K=M@_%R5Z<)XJ{u{N?q}a9g>r{mN9XH-T&o)+xlEqykkUeQ z3G30~awJTWpL1vNe*mZ!U~Kk!CRFc=nBPvb1KBZx5M<{){p99z`UT98KcVYX|1f4* Q_5bVt05T){XW>%-0FMYe4*&oF literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.br b/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.br deleted file mode 100644 index 64ff75497e0b12ba79d1489131493d32119fb630..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7644 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 diff --git a/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.gz b/apps/dashboard/build/_app/immutable/chunks/D-gDZzN6.js.gz deleted file mode 100644 index 466d96047fdc64515d8e0aa85610b450aaec9c36..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8427 zcmVsaw?yuRWEUY_y=Uha8{m#N}YydEfigV$2=5U;;-8egpV6}7DRJG|zSOT1>1&+uAE zp5gVG;$QLlC%>g?k|*@2_#Cg1RXT?jrzEk{;M&ai8?8oT0m0_4bXgJBg<&&o#lSN{{yL z??;PINfw1F&Qc+5#g*EV_e!RdVvh#VZHDJ;U6c!%dpYAfT2xS*TEl94r4+}1c%O%C z;C=S-AKomFm^TOn-Qe?x4Gxa`(=v^4D0?&MDW<#K3&n8M*K=MkLZxJ$21)>dk9&jT zKRzEH90#df?p?~8i~EK5<&T5)0&Dy8aN*_R%(RliAU+TE0J`0O9vvL}@?J(TpME^` zQf5dT`iruddFwQs%OD+|j`%!O(M;y>@coEq3mj~i1pB8vmxT)UPk1y7<5W)Iwqm>o zog90^KSuwAUVw>cB$*z`aC;Qpab!Ekku}GWwa0N{#&NoP9LJ+08VIz#pPR`#(Fvn^QYNFdW$eG(tFg? zTrd`AuD7x7gqdm2L@71NBgTikeZMqR-(NbiF9!**=;`5M zF+3R|v-V(7U?rA=9`VC~^@5V_kAXP`y+Gdr*?Uzz(}-2f|C+_A*Xy-zj|T@|7>7xP z^CAeV%59tpZ5-2r+Q*I$5BGuLpm{br`pkgC6bu$h)s+^lN`{Q5j*Q1Z#%Y|u#`7k! zQEd*@I7t;v%UrB0o{G8wo{7}fjKx_D!@0}i$=(U;ClXoiq(23Tg7-1p$B#olk?D<^ z_2VOPYMYHjIE+VBBN6E^epHM!ix^rT9!5UWA837e=s^+FKNRHg(Wx8zOq|Uu31Lbc zx@R0$$&88G#D-V`RO`#6kb5u!6{n@79TWLx^*0+ibPpphVL&{1fh;l-iQ_C7_7QB= z5(f=8{TZyp%nWtrTmCsbEO7>IG9Ha<9}B~Wx7S}~r2JdCDnKY0^1zrgb8E`??LaG< zMcuY*7$o-5QC&}t6-dJD($vhRsz&m%=lES<4F*66f?oZX{50zwd9$Q$Q#>bfNeDf zF_g24OVqwaFg)cT-)5W5a5SP3KqG2683Fr-tE^N|;si@1b%_GL$#5EEC`0UYroL{_ zveDEx_3ew-p_)PUd#_WHcT2*gDpsrO45sOJYy9}cb{GMB#^Qf~20$+byLePDRe^O( zx!CQ(K^zQIe-`3bQ=_i(T%o`b1bj%K1D?rOwvo^)06IarD}X70poVJ1st6Z)-Du;b z(n3qL;ZrTcB(6U;yVaV=x0@TcMW+!pp*RcoMOr3FgEuc)dulI+?!q)ew7688P3y%< z4V1xD!4D@VbsJ0hP#aVQfmhH2H3y6sCK|l;3=F%Ij=_h$7~b`Gub2UFk4k7rKZlD& zA|I)&jAoDM6|mS#0c8JKvB3bO`)hpo(>%Nr>oQM*cgkB=sEh!#n)@`oi*Eo_rZ+(- zJ)#3I7n4wdW=uhdR5j~d6IEU!d7pX>YOP4Qur-Q(Db&#^sfzx~p&a$uM8a#ihYwtW zs-SODgiz{rv%qUxplo)o9&Z1N zRbjD8qdnKh6Xg*m>Y)e%RrD##Z)M(#(>+6&EVuloM7RuNRe$hXb^IHt0NBRBr!*4p z)n`~#nW?PXNc?|`VeQi!Xu%pGxRy(9~) zeHZ3?s_!XrC+PD)@6X`Q2U_1U{Sw&LS2LLs!?(+Y{v8M+M8tCH;L1e^2-ey!{#fyr8#N z^!GRDg#w_M|)>HF7703{M%TK zPxBwraxR(P{)dN|533U%9)7zx72=aDg8NkYA1+@3R%)>yLYo#lww@Tj7BEoc2oEGK zU;^OQEW0h3AE&Wm?X`*hC`=O25scp|af332e-N&BdvlRUya4BbVK-9(aR8`R0JQuU z_W%HA2K>T*f&VXr7YUdlub@C++I`G5jl*Tsg7x8+LlXkL%o$vS$Pdl>))*sKhgYNfBuU^tOAXa0k+t+ zRf{xSfG$uB$nhFQF%(7=0cDBtrBUc8V;`*B{vd(J7ElKV${J(+M1#Rb!#=c+y*XhL zqHMVcqnYQSkHK`F@(lNz2bP5z=A%wOX?FmdO-2|ygRa3^X>|P+i*1}vb%1BFrA4`Dyu0Tf1&dye}Xg(dGS`c0-Xx8|_7ZlzpIVN(GN z_3{2W-t#omYy~gV?22wX>m9aOo!gh1&2u@4b3mu#C@WJ1m=;vXSY@{|4RRhvkzA;N z^wZXmy(^NEsTjiEd1{Oc2CBYU67);s$t}!#AZgVuNp1cFmH}ykpUjoIhQ{5Bg1#-X zGLK}CRlKl^8~0NyDN|@ON=gtaAems4Ajfber%-R^*4BuwjN!^|t=BEVBhb9ck0&5O zy)ESxPrz8iHM3d(Y}S6L{BSY>+y{yZp*q&)nv@}5Xk8!tsz}x-cp=fI0JGanRf;nY zn$Va7TaiBU0b2c7P)@)EmwMGStTtQ&@`9r>)q2dD{dd0Uu{*iM?HuU_j~kMBFGEfR zRI{}Ub3pB~A6mFzkc*E*#N`hyu;*xdhtrXTuurlKo>S*W%R$nE-5T>rOa1XKqc}c_6oI1j zDYPhjM4SxNIw|jKm?;opt->5IlU}z)5zvz9@|g#y%Kg8_nNzKoOPLrUBT0H>vKaE{22!PXqA{&Tl03vpJ^WqC}d*<9F0pr+F>5e zguUro1J+1!vv-ZyeUKa-DpZ#78b0$P7)$Fsn2NJ0K_}mFp|PFLm3I%qwO=$R6B%Ad z+KPf1FBlkKGqHcq%Z3MSiuaG51uw1Xe&g$*TFbpZZTQwELJp@RJ{GnVJoUXvo5&MF zr$}RO-2O7wUl2qA`!GHs2ORFX1pN`ZB8;`3$nXok8Xv67>dQ!=S%{-Cvd`PU@qx_9 z8_4m{AwAQ>W^<#3C%jEJnGEwhQEzuCXVx_I$GDPBiOY)ePU< zn~E8J*Tp$bE0_(E;9gIf@u({*FJV&=Q{|eGVCi8r*r>FF%gx|Y>%AgsA-e!)X%U<7 znem>I)uz`m7VC*z$aEspCa0PV(H`qN~^cEPm%U3)y>ID_13Bk}{ zzy`7t(F29;U#2nK6k!qo4@ACubf!?^W2J%FUO2O!CR@SF0tOvdK}|}a>-Oppw;6)d z76++1YxUKxG4sK0j*~dOxgvqEt4%E`8piXLv-yzBxoEjrE+uHO0(~tc5Bg2tA+iNX zMb=OKERS#E6a9>yvq`m%0>FUxFiQY0b>&(j7buZa zzr{G{L(j>3SFmr?sS9VrVno|qzk;W4RBLiLR{mWZG#FWM_Edqf9oK}NWKElUrQJ$K z;HWk?C<1N_ksGn+03h_kMT*;a(Hn%CA2o=p`!Vh-B(|mfo^vo8s=cF08~kn8zu~4M z?6RXMC*Zc@!-zGgmTQ&i+}oX|03`u(#|UmF!UsM9C!-EuAx_Ae@SLGz!+lCSpQOdY zxs~jDvL?+dFxs_DRwR9_K(2*gW!Go7CjNG1?%YLA71!#Ox3n@8sk%ZMVLqAw+!;9J z#e7IiTVnvFGpzMag9CWQu|RDn-1%f-fX!h6zh;27arzg|xgTp+epHE+CuFq6JR0>2 zhvMeqY~Jp74(1s7s;!HX@#I^@3EX#TxHuLm;Q>$i47HTLu1>Ki3av#?Y6%Z&OxnwA!weFb#( z_3@(r72!_Xpn1=|zl@rl48L~$8-Hn~XJ`Gs+C~N-)8@mIkyWfDmW(Q;_gfS)D%-?8 z(LK|Y8*`K!6E<(NL*E9ih9ftrIZSH)II%(7InE7J0*3Pu!wAY)$Ik8C<~APVEoieW znu_(#ZV@vJ>)z;bYXt=hm#R`Bm%vs+O_RCQfLgHV9)I%|eC^guFJX=SkZIACv3qGN z&9WCaDUhtWqc3i?;#KNziX zp`V*NA0+IZF)ti@oDZz!wk;6H26&wCb7<@ywtJQWIlXf-N0^1VD`U}I)ub@={9SpH zyTR})z5=@u%`~&lHnwlI-NPfXeSLp&()8)uZAHL3bmlQC)-Auo2Zz!qE~Fkk>Lc$_ z)XxGp9WvSvhxw?_@<-ydUxy1}9``|hbjoQ9X;iDHiA}%~neC5H8j-H;)-wSJ2Y0pm z#>56)gndi1yaIZdc`GyPu(i(3STu+ZoJ6KUJ`UTa>F7Z=1k_BmdDxnwxfM^igS%b; zjMD8ABpJv84%S429>3JY_@y)J7D0$eM2iPGAa%;Q;PHrWQNu8RUT`fc3KA8?PEmpW zSqJ=_aNr%c39K71rJCj0ad7D99b+h|k&80;ZsZ@)%b@lv843H!*>n`Gt$WKGDFA=dRijmQ zWTAWA(l5?IN9rI5^$&|6+_3H9_x_kog zpP_TitkjFm=5-xgNW@vKbv!2RgkdsccogV& z>x5lmancC9L|DSaUJ~(M@oSJpx4{f=^?H=Xi}Te`Xer+I--^gQO>1v{h~9iY5tQkw zeYyi$t|=^*Vu57*F^4m&z|33LQ@4d;?-g8(`Ffza3{S@yh z_uB2k>IQPM1x}6TaC8UW)t$aK$FN0dh+cZ5MF1wBL3&v zU9)iEB?pp;B=O_#PuRL0i&QPAWsRUgV*h`4!PXW)5LIshpuxnSmdP|uI*72c3(`PB zKR5)~ToyxwOViO_l4XnD|B3ufpFrci#;J>jU)ZEqor!;+oVegv7r6t|?*Q${T*QhP zcjwp28&e#44is&6fSzm1Jh0p~Ct<6#Vt%j=W~j=62^<31_nj~2R%C;d;FNz7Yf5%F z61O_vfo|TYQBYKUFB|Mim5!^<&p(0oLGH*lo0aq~_@y;ER=61-a&S!H zI?%a6MDxB*`Qck6m!hDpO%|0@^_0Br0Ofg}hbzkS_AVqp5N8KoOGdzdHe3lG4MsYE zePIQ^jwaq3b$oWBRp5cJ-#xaztz%&dRMK+`d%r@@u@gz=zx415-NzbXF!WuvK%P_fk%*rUSxDr7g1_!Uz_ zUQi^D_+7XE6EuX`U!YHnhbe@~-$|3+6P#BrMBCRjt_-XHJUms`_<9e3X7r2EZ%AOn6s2ju$K;o*Tqz5AY-JhJv`cEix^6``Cn zQq~|=i5WoK>1c6R9P+k?%z#lkZ_Ly&Ba-ntT6-(bZaX`Ge@mh21k?@|`d!u0fkx)4 zi vFhDal>&&TIe(ir$gDp{R1Hw|nY$Jq2=RUy9%e0Y>^AfX`kf|^sb1e-wY8r7g z!_0lfW&Z>2whII&uRu)66n1=Xo|Ofq2=u^UJ*(4?eVqc(j}pMl@8h|IaiD>q1dzu* z6aLJ+i2n&z8kn%G;@_XJW=?aC`N=VegK1bM>RnFINKQ7J3?MJXZVNei2PE+rX2kso z-7Z-5;6NwYGVP(MwW|bW+|r2`D1u%f;ITWM@70PhQD$!;X@GC9wegMdk9BP}MQAp~ zEb`-`E}hjLw8UVv%43w`mxX$}c${N5honV9Ak?{0_t4*?i9x!H^v9Rqm`Sk!p-$vpz7s^-u{ zGpC*fFsGoUH@(ek1YeTGZMm~=C7=W?n_GQE*@RHRH#&)Uf&*sF1bVhkDa$rXQ-qIA z>p4a?_|Q(d!I(}j>{+9nNE_9pO={B4h_rE=w6r$vK#V!t2gHq8zjOrj%GRWS&VTxM zAieQ~D5iK>E{g%GZI_fFNg*2sN`Ef2;is9fzzFW+c?D=YjI>c`hh- z-WrhBIWr5>Ng_4gbb%#p1%=i>CAmG5nWIByT|d=>dP43Krqa1c(VITE_09 zj2+Ytxi0j_?7?8qxHGT;Sh2ulBAztp@ZKf6Y2c$;z~^@jTwuoJoz^Q(JQY^8%c$ck z>zi6qoJpN!412U08^^p;lf3zVNSoajbk`DCRF=eLJ>cpy@ z5eQE9K&FGh$CxF07Se}23pph?{zsmLhCjh&MdbreBA4PMo@qsZd3(NI;*VicN`bzb zZ_pwvRo26VvMpNN#YKD_C$U;Zz=b!U#%SmcnbhA2rX#eN#gmCl0azfVpiz(*^}zun z1`rn5jEm4OfLzZ&f^9aaZg(o5D2bz6SS%9mQlILS{&lHTmTorEU(Vua226X34|A!) zpXCZ~Bb6uSwwT3JW$weo-gQ-H*W(8YL+;R|AJ~rbsoHs33#*KqM8BezS}{qjye+j{ zsslb0NW`&ri}yAg{ix8k#7QsX6xuSm5HMl=Y^rOijcw?Jqu#iX$+Xv=Qv~8LH%cXM z3a6`&Kb{-#$xsXea#UHACCw~<`wrlhS3l9RE43(s9_C|oUk5$5*~G0;3}?I?3F}@= zA8;?49dFNgeg}JMDez<=JlP>>PwQqA8SxG(Y9AErKB%F!^*^O1?J$W`U?MF!(Ql3J zpkRCR^y`C%Wy6cOG<$x?r=v#FS7UTI6ck4#)BL%$D@!_MyV=kc*A#O|fi-0Q>;X%I zN+A>=oa~H?HM}OcQwvT25r5OxM4}S=aQX77&FVvC-JcM)?;0{_5um%pW2|uy^JkP< zIz1gk76`(~Z+T$sBICi9Y6k(#L88X-q$x^5ov?JC#&cTJ=Q$vF4SySOc#4_@BSMWg zrziBTliRM>S+9KUH;R0BUwe=u-`;jyNu7xe2B}pxEp=3LQ?*-i73DQp%vz5SQ~aI8 zdGY@BtLIrhH!G)i6VA(z5?Hi1l$ME}2WdetPX&lK>IWnbG9l*icG7n-Uin^^-)wSQ zm4wT65(2#d7wxX~TB=z#p;~i&i=qW;cLYo9RQ7f|u)oih%HwMcGWD?4&|m=cU+wJn zT&oG}R+rT$P&MSkEb@+2v*h3j2)Ib2K_e4v(Vcn{^xy)R5iDeVdaceW!Rg>ipl$*y z34msxuSX_c4$~2O2W@dRq63*Vm)I}4gfE?V zXyocW8Nq_;?4G97*Gj-8`p{u}cy|fh^g?Ymc-&p5+)^v>_TGB-P;vpX#|(A!UGNNa zr4_50f6p_2g{Q>Qb`+r$>7$E&N6yp))yr#~)obewwP7t2_b98@nHT7TUy7(Q0T_B` zLE25`Ju1Ptt$o&S8;fhz{Ql4FgW=ox_HbgT$BD47q`mxaY3$ac)m*O2he<(^*x)olL{A=$V44~ zsGR}{ir38s(=TS?77vW46OS?urxkF+lz!SFp6G^4fMhU)I@e$dFr-eK8}qsQ`GLKK zh=+5R9JjFYWkIQJ<2pC(h>d|jo6Uqk zWrUeiC)}pMfe12qHrdKmnOHwS=(tMrh@s8Q92l?}D^rs7(@w_9+B!ikBTXMlSaBG+ z+zyvrU=*|yFq`uA?lm*vu%z*zh7#rO!LGKA@W0 zeg0v`7~1LXG?a=C+RyRKZ7tUhv_EM7q|ShO=p5V-T?B+y%;`7Dq_q#4Hb^d%&7R30 z4xi-Cy>}10b`=yAYT|y^^=)BgOSkmr6!zHqJp{|LU%oq7=hc@kzwXvtF{&n5i?E3S zI6wrVl+m;oC3`Gbays_Fh>`0K?NusBtZxqCmsm<~zIrbE1)>)kvDf zUp*=w191@pJjDolzd(7JY1dmyKly;)K>2}`-dZ_2uTfWS{1%W-h5S|@ZrSnN1pvWL zXE+OrZOpUu93&U6D#{A{0U=BaiXQrg=W;20(JtM7g@s_xw~I7ixK`dyr!ecf3H@y9 zH$J*2>!V5S(j^Ja3jM|vYvy}>Xhgp>8fhJ>0tRhaT<(WHKowKONR+^w%gX7lxSb`< z*R_K&&__cpG*G*ageF4mJQA98kA#w#vY?mFeyS`0VQpLYw$9}{5!Fbo)t%0^5Ap9B z!>l_7Y5PyxCr?cZQeK}qjVrE0o*;s>4;JK5y$I*3sW1?BDg6T&#sRMn`e`joUfDU{ zO+-UHlbK=;9=o(slj2d+uQ7x-t+dZZ3Z?tmH%g)0;nvaldLY;8#z-!cCp)CH5M9E0 zw747zljP^zS^QrBss$LEy`BlxyCUYd)9gTYj35Nrc~3vN`J8?MGvrU`dZT|Bv#9$2 N^}q3IMTp^3005-EQYQca diff --git a/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js b/apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js similarity index 88% rename from apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js rename to apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js index cd5566d..8fe3a65 100644 --- a/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js +++ b/apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js @@ -1 +1 @@ -var x=t=>{throw TypeError(t)};var B=(t,e,n)=>e.has(t)||x("Cannot "+n);var a=(t,e,n)=>(B(t,e,"read from private field"),n?n.call(t):e.get(t)),c=(t,e,n)=>e.has(t)?x("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,n);import{o as I}from"./GG5zm9kr.js";import{s as u,g as f,h as d}from"./CpWkWWOo.js";import{w as G}from"./BeMFXnHE.js";new URL("sveltekit-internal://");function ae(t,e){return t==="/"||e==="ignore"?t:e==="never"?t.endsWith("/")?t.slice(0,-1):t:e==="always"&&!t.endsWith("/")?t+"/":t}function oe(t){return t.split("%25").map(decodeURI).join("%25")}function ie(t){for(const e in t)t[e]=decodeURIComponent(t[e]);return t}function le({href:t}){return t.split("#")[0]}function W(...t){let e=5381;for(const n of t)if(typeof n=="string"){let r=n.length;for(;r;)e=e*33^n.charCodeAt(--r)}else if(ArrayBuffer.isView(n)){const r=new Uint8Array(n.buffer,n.byteOffset,n.byteLength);let s=r.length;for(;s;)e=e*33^r[--s]}else throw new TypeError("value must be a string or TypedArray");return(e>>>0).toString(36)}new TextEncoder;new TextDecoder;function X(t){const e=atob(t),n=new Uint8Array(e.length);for(let r=0;r((t instanceof Request?t.method:(e==null?void 0:e.method)||"GET")!=="GET"&&b.delete(U(t)),z(t,e));const b=new Map;function ce(t,e){const n=U(t,e),r=document.querySelector(n);if(r!=null&&r.textContent){r.remove();let{body:s,...l}=JSON.parse(r.textContent);const o=r.getAttribute("data-ttl");return o&&b.set(n,{body:s,init:l,ttl:1e3*Number(o)}),r.getAttribute("data-b64")!==null&&(s=X(s)),Promise.resolve(new Response(s,l))}return window.fetch(t,e)}function ue(t,e,n){if(b.size>0){const r=U(t,n),s=b.get(r);if(s){if(performance.now()o)}function s(o){n=!1,e.set(o)}function l(o){let i;return e.subscribe(h=>{(i===void 0||n&&h!==i)&&o(i=h)})}return{notify:r,set:s,subscribe:l}}const D={v:()=>{}};function Re(){const{set:t,subscribe:e}=G(!1);let n;async function r(){clearTimeout(n);try{const s=await fetch(`${M}/_app/version.json`,{headers:{pragma:"no-cache","cache-control":"no-cache"}});if(!s.ok)return!1;const o=(await s.json()).version!==F;return o&&(t(!0),D.v(),clearTimeout(n)),o}catch{return!1}}return{subscribe:e,check:r}}function Q(t,e,n){return t.origin!==Y||!t.pathname.startsWith(e)?!0:n?t.pathname!==location.pathname:!1}function Se(t){}const H=new Set(["load","prerender","csr","ssr","trailingSlash","config"]);[...H];const Z=new Set([...H]);[...Z];let E,O,T;const ee=I.toString().includes("$$")||/function \w+\(\) \{\}/.test(I.toString());var _,m,w,p,v,y,A,R,P,S,V,k,j;ee?(E={data:{},form:null,error:null,params:{},route:{id:null},state:{},status:-1,url:new URL("https://example.com")},O={current:null},T={current:!1}):(E=new(P=class{constructor(){c(this,_,u({}));c(this,m,u(null));c(this,w,u(null));c(this,p,u({}));c(this,v,u({id:null}));c(this,y,u({}));c(this,A,u(-1));c(this,R,u(new URL("https://example.com")))}get data(){return f(a(this,_))}set data(e){d(a(this,_),e)}get form(){return f(a(this,m))}set form(e){d(a(this,m),e)}get error(){return f(a(this,w))}set error(e){d(a(this,w),e)}get params(){return f(a(this,p))}set params(e){d(a(this,p),e)}get route(){return f(a(this,v))}set route(e){d(a(this,v),e)}get state(){return f(a(this,y))}set state(e){d(a(this,y),e)}get status(){return f(a(this,A))}set status(e){d(a(this,A),e)}get url(){return f(a(this,R))}set url(e){d(a(this,R),e)}},_=new WeakMap,m=new WeakMap,w=new WeakMap,p=new WeakMap,v=new WeakMap,y=new WeakMap,A=new WeakMap,R=new WeakMap,P),O=new(V=class{constructor(){c(this,S,u(null))}get current(){return f(a(this,S))}set current(e){d(a(this,S),e)}},S=new WeakMap,V),T=new(j=class{constructor(){c(this,k,u(!1))}get current(){return f(a(this,k))}set current(e){d(a(this,k),e)}},k=new WeakMap,j),D.v=()=>T.current=!0);function Ue(t){Object.assign(E,t)}export{be as H,_e as N,ge as P,he as S,ye as a,J as b,Re as c,le as d,ie as e,pe as f,ve as g,ae as h,Q as i,N as j,oe as k,fe as l,ue as m,O as n,Y as o,E as p,ce as q,me as r,we as s,de as t,Ae as u,Ue as v,Se as w}; +var x=t=>{throw TypeError(t)};var B=(t,e,n)=>e.has(t)||x("Cannot "+n);var a=(t,e,n)=>(B(t,e,"read from private field"),n?n.call(t):e.get(t)),c=(t,e,n)=>e.has(t)?x("Cannot add the same private member more than once"):e instanceof WeakSet?e.add(t):e.set(t,n);import{o as I}from"./GG5zm9kr.js";import{s as u,g as f,h as d}from"./CpWkWWOo.js";import{w as G}from"./BeMFXnHE.js";new URL("sveltekit-internal://");function ae(t,e){return t==="/"||e==="ignore"?t:e==="never"?t.endsWith("/")?t.slice(0,-1):t:e==="always"&&!t.endsWith("/")?t+"/":t}function oe(t){return t.split("%25").map(decodeURI).join("%25")}function ie(t){for(const e in t)t[e]=decodeURIComponent(t[e]);return t}function le({href:t}){return t.split("#")[0]}function W(...t){let e=5381;for(const n of t)if(typeof n=="string"){let r=n.length;for(;r;)e=e*33^n.charCodeAt(--r)}else if(ArrayBuffer.isView(n)){const r=new Uint8Array(n.buffer,n.byteOffset,n.byteLength);let s=r.length;for(;s;)e=e*33^r[--s]}else throw new TypeError("value must be a string or TypedArray");return(e>>>0).toString(36)}new TextEncoder;new TextDecoder;function X(t){const e=atob(t),n=new Uint8Array(e.length);for(let r=0;r((t instanceof Request?t.method:(e==null?void 0:e.method)||"GET")!=="GET"&&b.delete(U(t)),z(t,e));const b=new Map;function ce(t,e){const n=U(t,e),r=document.querySelector(n);if(r!=null&&r.textContent){r.remove();let{body:s,...l}=JSON.parse(r.textContent);const o=r.getAttribute("data-ttl");return o&&b.set(n,{body:s,init:l,ttl:1e3*Number(o)}),r.getAttribute("data-b64")!==null&&(s=X(s)),Promise.resolve(new Response(s,l))}return window.fetch(t,e)}function ue(t,e,n){if(b.size>0){const r=U(t,n),s=b.get(r);if(s){if(performance.now()o)}function s(o){n=!1,e.set(o)}function l(o){let i;return e.subscribe(h=>{(i===void 0||n&&h!==i)&&o(i=h)})}return{notify:r,set:s,subscribe:l}}const D={v:()=>{}};function Re(){const{set:t,subscribe:e}=G(!1);let n;async function r(){clearTimeout(n);try{const s=await fetch(`${M}/_app/version.json`,{headers:{pragma:"no-cache","cache-control":"no-cache"}});if(!s.ok)return!1;const o=(await s.json()).version!==F;return o&&(t(!0),D.v(),clearTimeout(n)),o}catch{return!1}}return{subscribe:e,check:r}}function Q(t,e,n){return t.origin!==Y||!t.pathname.startsWith(e)?!0:n?t.pathname!==location.pathname:!1}function Se(t){}const H=new Set(["load","prerender","csr","ssr","trailingSlash","config"]);[...H];const Z=new Set([...H]);[...Z];let E,O,T;const ee=I.toString().includes("$$")||/function \w+\(\) \{\}/.test(I.toString());var _,w,m,p,v,y,A,R,P,S,V,k,j;ee?(E={data:{},form:null,error:null,params:{},route:{id:null},state:{},status:-1,url:new URL("https://example.com")},O={current:null},T={current:!1}):(E=new(P=class{constructor(){c(this,_,u({}));c(this,w,u(null));c(this,m,u(null));c(this,p,u({}));c(this,v,u({id:null}));c(this,y,u({}));c(this,A,u(-1));c(this,R,u(new URL("https://example.com")))}get data(){return f(a(this,_))}set data(e){d(a(this,_),e)}get form(){return f(a(this,w))}set form(e){d(a(this,w),e)}get error(){return f(a(this,m))}set error(e){d(a(this,m),e)}get params(){return f(a(this,p))}set params(e){d(a(this,p),e)}get route(){return f(a(this,v))}set route(e){d(a(this,v),e)}get state(){return f(a(this,y))}set state(e){d(a(this,y),e)}get status(){return f(a(this,A))}set status(e){d(a(this,A),e)}get url(){return f(a(this,R))}set url(e){d(a(this,R),e)}},_=new WeakMap,w=new WeakMap,m=new WeakMap,p=new WeakMap,v=new WeakMap,y=new WeakMap,A=new WeakMap,R=new WeakMap,P),O=new(V=class{constructor(){c(this,S,u(null))}get current(){return f(a(this,S))}set current(e){d(a(this,S),e)}},S=new WeakMap,V),T=new(j=class{constructor(){c(this,k,u(!1))}get current(){return f(a(this,k))}set current(e){d(a(this,k),e)}},k=new WeakMap,j),D.v=()=>T.current=!0);function Ue(t){Object.assign(E,t)}export{be as H,_e as N,ge as P,he as S,ye as a,J as b,Re as c,le as d,ie as e,pe as f,ve as g,ae as h,Q as i,N as j,oe as k,fe as l,ue as m,O as n,Y as o,E as p,ce as q,we as r,me as s,de as t,Ae as u,Ue as v,Se as w}; diff --git a/apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js.br b/apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js.br new file mode 100644 index 0000000000000000000000000000000000000000..8a34f5722d0e531c996e31da471ed79193e4f250 GIT binary patch literal 2609 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 TD0E~~pK~*GLBhsX6=eGd^~w_U literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js.gz b/apps/dashboard/build/_app/immutable/chunks/D8UfWY0j.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..62beff4715669bc654b407e96b01bffc52058cd4 GIT binary patch literal 2952 zcmV;33wQJ%iwFP!000026O|cjSK~JJ`~C{!vN?7U4h(Hi*Qwz!l+JW^2Brk&Q6>e& zRuY3FxssAh#`wSQy^>#H*x9pRkfr<3ec!9Fq|*5u>FBV~GbvWiZEM&oyY54F-{Pk5w?M*aE96e)>qI1?ToU{3uNoOu310dy&;4yQ7sgrW0 zDQv{VdC%zmkm(~901tbm!YkpXK|0Tc)P-=Ua(*vSSU2duc=6+x`M>UEaHrfFLm|e3 zOmUfz87@hUf0DnyfB*hmbn#b+@uJ3f&ffg?fxkR87@Vz~tBcp3tClR&>^{}IDc4ML znuYzo>klRi9_v(ahcdK?Ur44Gk~=zzBDe28JTUx7rySIFk926ZoGqDzUBGyv-luxz z0jdvsm8CKB_Q>wOA6B?DThX<0d%dl%(05=7b=im@K!jF+K;>DgJ@=o_esuj{PIE6| zu}Ij}#qWM_CsJO4TKd$`PavXV0WNXSGmiH4H5)|@?TG-RamK+ZaPAN4>smG$^NN{d z6A%CEn{N4+K0B+3~+!y_L@bmtl6#!J4fB@;l(-7?N&A}i_%al)DOClp4 zWQidaW|bzsQN`MMZypftyfGceTzMzdHgI#A3)v%{=9)4l@F1;XXU~{%nC2))RgSN<77H z{L>G{URHijMISr`hI$KyFI5cWS0V!i&`=jlL7IcSie$cDRx)%QXpGe+@`6lXOuNJdjF|1l zG@dco37)NY(}~?DF0rvO3Q`_ti-akUZw3vvFu?TvIzBfv4A7iJ1!zux&_ofGj3@O* zC0o61&{W0fR>d;S^|i5f+cFFtOGfs5A+u<^Fd<r?c9jpWBG227rkNPi>~fZ> z;O3^W=FPs8S@LY+Z@PFp7*oakqa(MUz%^q*W#XD~=cHo#2AH1we@ssTsvzYQuzdxb zUGiJxJ`47PX9q5su&A91Ld9vWW&%Pr**uS>$TFAAHcvH7M9L-8jnkY?893Y}@`LUjV^fo<4Lr9|Vybbw*H)hVeB9FqPtWB93_ zuP^EJ3`RrGMJlLptm)!M9HxW7Ob-nyTw8YX7RRy8(gU38L8JI=toWg7(`&Q)Xm@2x zG2NWiHf!bWqwL)-Sb6JL9qn~gK>)q*7&@fJS-sO0(9o{mI#oxgLdQ_crmC9)H_&p8_f%67dZHU3!*?%^D=&k> z$lS!mI~bPjmOPFZ7(TF(Vqt(06{~CiukWt^>W})(M3%N;YS21^IUxzO{?s{vkAA_DtucwSZsh<^I`wU?mv@J!I8nFR`L3m{Cz6Gs3e zEsO*;ZYVllT(dSX@m`$xaFKRVcFF7_?2<;>4zg*lmqLU!o~u79+YNkBrk*HdH1$&A z=3ozyVHbx_>?bPf%p4mSm};iuv>41{+%uL>;3|b+-h#OWb5T`RfMzW;vrx+&VWNeJ z8kT1?W~KxqMhY>Xb{=vw@85o*Rw)J}e8pIz+|VpqE|?oyA8hRn%o&u`3Ti5A1KuB0 z!%KBg&k{wY`VATRsR3vc0H_Agm?DIx3dX2ZhaF5*mI%Hx{5GoH7~SAV zbW{15b!Yzr5A+AhNH%!8;tdjZHs91(j z*ba-bQ-Ck96BvX7DRqaEm7w$1ex>w)sx^Pj%&Z=IKcr@gH`pZppuJ)b;M1d^aCgf;gj7CYu4AWM87%1*@m zQP=*aPuemCcYlPMh%HUeI5ryyIH~PV6EK2p!N7ggLIJ(0;PqJuLNxabO=MP%eQ8?D z5JKzPHA!rW1+-4EESgc_UuFJkNz)AG(P0MV9$|t{(y2T02RP@x992gAv*l=xE%?uo ziG)*fPA)4%#-iWbcXhXVZ*OCH?>7>ETJ3!DKKah4;#1j&2c6Phm(u>sc0*QVPI9s& zYjR93$XhZb@5nv58!&d{okoR8^r9sA`Uy?ZW%z@D{e*FW&J}_sxRHfLnixPyY<3s+ z1BwC+b=VJ@pQ>hB=PK;?*=IV>GkBqkx$BqYJSyUa#2KXGbJ-q%H~bJp0v_JmCnJ=l=!H&`xWewTYED9>LhkdQp)gv`cqk=t^>9G8um(enWGz+StuEcKOC`xv^Vs?2b2f7aO~`K4cB%#Jg|h z#IT8Yqgs_yPpCJn)T=SNDh?|ZhZ_RC^C3%7fV*!Aa1R1NXZv5*-+$x!`|A4pjqC4B zM~Se_UIrBz3B^Mu^YI;v>lcrAO5h2>KAWG`@%K#Syo9GKu4nMz#q}*bhjAT} zwOJ{7h0B;+m~BilvnC`pDu>t-~R%VrCZdMqe&8o>Uv;Rf7GV78I&AKWF|M(Ab_l>fN82|v{!lZow literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.br b/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.br deleted file mode 100644 index 986afe9f7fd3f3fbf542cdde288dfa5b62a981dd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2609 zcmV-13eNQ#h#4Rp2jzA$2N-tK?*EfPlBE7@>UZDE$tYe%+NGHPyFA3Hos>?%JPfgr zi1chi!0`3u($m$up{eYD6JU*Nb&Kx-mbn8Y152HIC?fwiS5_|MZVMb$;p!{QrYuRR zy3PN8CU0jJUPId#ILO`=woI71+LULtQrTS|5vDCWOFGXC4fObXiAh(bFG6pLTR)-9pMJ*?!@z#CU)TvI{h%bEG8>6hS(LE&sPK%ISs!QQP|xC1AvUZqo#5u%eKr{S0h zl4~M5h5tY9isyN#NdykSKcD;w#%UNKH`I5g8_cIY(&2Ii;mB94E$ssI`Hf@USQzeq zfAT8p^k<^CRR)_#T~{kZDoXmkK{l?07HF?L6&UlVl%`l6?NV?4lK2O;No7s1WoJ3M zM)*cA_ME=I%VsSxlN;-TSw??#T{EPBYVScZYOo~Qo((pVnm~>^!IN21YJ}J;QdqCo z4>b)W&F{}yhS`cw+?568>oI8H4pezJYY2t$I)~k=AM| zO{GG1^dd=#ZR;wgncR=rr0sV}SweJDd`)ifJWr&xBu?Xr>XE1KBxOBEB$8Myv+zt1 zvI><)kcYk`d{DSg;sQJqJc#fAskXMJR>VRDP%F3UB!956PR?85tU@%^bnn_V9I@~d}!5Sl-UMsUc zDIke&m^`Y!{dkmoB6vz`pw|ep7bpCPrZeogf-3tNm3dnaO!Orw8QHcmp^_)h^RiF&RKrjtj}2O3o1-jQI>|f z;$yIR=vBCzd6SRPtHd%#o(@9`2;Usvh+~4@PaK^5l#2>j zDZg&$rF#ZgKOug$XNoUTMT@7p9d7n?JZ`(&)mAmn<)iESiL>Xv)u4WROvoc7LA1E} zpVYQ!$;p_J4OcoD3oAz+r-Wm+!s@AVCVo(wt8`R*br6<7e=rb$Q+KqaDo5FZ zCOCMUMbto%+Y{OLK?B0_-Es5ggi)A9wkhe8X}GQ7bf1K*-fL>v0vD{o91)A$= z#Q?NEfT&z;bS~1gsxJjQ%DANANgI`~T^K5l^hO`{Hw)UCU_l~l^xP(bLw4z~OdzB# z1=+wF;T!p{YfrEK%LAjVUUDj8Dz@Z0!7%s4C*v^I4d2#=U75E#NW9uz{i>tit;FJ% zrk9#t)|taz=LlPR?k&sA{bkYAxYXQJRIrH-L2MF_uoPa!e>N+hsiYeDD(CAE%2XGA zRo6jy?B;Vp@us6?4v0=O_?loNE=X_(H=rNLRY7K3#+w+m>&PWdYeo~Aib|s`dzJF8 zT`t1P%$FJYW{ug2jf!=&XQhPHt$5*ncl8Al25B?~Y8z~eKm%x*V=EahMN*Tl9EB^~ zii9R80(cauc7+XVl)`{?dFhW*w&ms(t;O{-wLNDy0jh$fOL7sMT_f;p;l##9U;3{?Q#X~ z6*QNk^IVL}Lwc)NLB3_{W>&At0J{vcPKM2=P~E>_+3KTW%anNpk!O;vvw|4`hKGCfKYOD|=rv0i9}e%(0uc@&E^ z5<7KS7l7&11iyhMxk_=^UN6j>~OYzTD1d~){>yXU7g)6!wq`twfE9#xN3#hk7 zo$L`BRw%?R@Cn=sqLLAFva*#2+GVLIkUo)mjPimy(}0rVbRloB&v&&_&LWYR0z~Tt z8w_fuu6HodvHln+x-g8)BQV4KUCz12y#OLSY+5S<+#U`keBDpKYa>WG^x6FBO5EHs^Mo*p-KF zCD3qlme8`jFm@fN1gp17Syg-135>nn%PBdx{zn#6{Tc=ZlBlD*v?XeQG^w2mU~G)F zacOLgo5ri=g*dMkV|`nXm>zS-s@3Lls6`w}&1G9;jGDLNIt^p}o}C|^6`aO)-ZnSR z<-1Z5*0kQc>hr|V8re(oMtak$9<0%`7TpDvan-wSr*RAqh!^!UX8Hw%9?=E~M~5)w z3KC8cJ3XV+fm+X5>NAp{;Bp(3obAJRltVZt-|K=!P;tH+E_oQP*bQr@?%@a3PS-TL TA=8mfeZkGpB@r82Rgmo;K{gN4 diff --git a/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.gz b/apps/dashboard/build/_app/immutable/chunks/DGcYlAAw.js.gz deleted file mode 100644 index 2fd77b7ed6c435c37b2c54b466cf8cecbd3bfc62..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2953 zcmV;43wHD$iwFP!000026O|cjSKB!D`~C{!VRP(3IM7b#%sOK@lrrsfTj&tzV`v5x zTS*L#@R+&4)JeJ0 z6gFbwd|>o$$n+r#fQP+O;gxXHAf4wz>OweFIlq@EtQ+)SzI^s|{;xY3+$y)mP>8W0 zQ(PuwhD%c8ALk$LK72S6UHlbdysR;vv$wx}Dc zfa=3uWogX3J+iy+hZQc(R&=f0UT^Cg^c`42T{a>J5TO+yP`Jr-az&Nw&)&iz4sUCSn8UNMtw z0-}8@%@3}BwKr;!KX^e9z^xgB`=V!0f7u_j0)R>r5Fnj+8iF0ZIT%D~newS?No2%> zjPa?S8M1*K_$*>SK7INZMD2{qV-WgCd%L^RFIlEQqltGUC0##XOeRbQsd}HXmB)R* zuvY>@bU8Tr7lY^VU~Etce5^G)n@k`etIZp8vp+ydR3tYfQH><>YIj$S?DaNv@rpKm z-6hQykRJ=Ue#{)|SPdN^4N_v{aBE9@?BL*F&kwX18Z__e&wgnbvM>6CqnG5M-oIdW z-hp74h{vq}@+sABEBH;}*9=L5O3+B?2RtCS~V z6-=0pXM^s>6cDUHp6(WabN2UwDGj+WXL=@*(1R@Ci!3`_iZpTdpdeTPls5O}$%X50 zK}_IBuQv`72EsD$($uK0<_3RYMHw3<-_pD_MqH(A6>QO^*%BEgB3{fP!~>8;u7|)h z)?f&%K@(4I8F_j=8E7!^v4DEOG4BG&=3>b_6A#5$B@pOR|))RgSN<7AI z{PR!7URHijMISu{hI$8uFI5cWS0V!i&`{@0L7IcSie$cDRx)%QXpGe+@`6lXOuNJdjF|1l zG@dco37)NY(}~?DF0rvO3Q`_ti-akUZw3vvFu?TvIzBfv4A7iJ1!zux&_ofGj7RlG zC0o61&{W0fM#VDC^_8)9+cFFtOGfs5A+u<^Fd<n;FWr>r?c9jpWBhTB8rkNPi>|&Ox z;QG3;=JmdO#vwiZO&4zmW2%^cc0d9>Xg(54oQEKG5l1| z*B5kp3ZtRtA{A6P)^zbh4%0zkriX?Ut}Q!xi{sd4=~+R|tp<(ai?QOzs!gxW?vve> zEyZ+mR@{l9*=`l~iE=};Xt`i+XnnA?H!x>VRx7BftPOa7 zPz^8DK|Mr0aa@rI~#h(8Kd$doink}IO}7rt1Aax(NsHj z{=3;O-j@Aqn&*8e{|XD!trGl(6xA>lf{*ERPD6;&W@I%hWCYjXJGTQWOEU{^sX*NM zP4Lw30?*#8%oU#R2i28exZgT215bNfdp>y)EIpq*Py~{oDugxnCKfy9As|b97s^h= z{888brcc^31$Tdfnusk;&p0+42so+jPZKbLZNb2O*g^rlso?cl2tqXX3{7NKj(ufX z%Me2A$~8%BiUqVzuq>KU;a_F`YDv=!=FwpWTIVY4_t_UZ&og+Ti@EEUG zDjWK8VP3wF9G-?blw6aASCsguw);8kkz0GR`sO5mK(oYstxbEpet>oa``!I^e~yg5 zt0TNqp$R%@)@C4dCLXOs2e7KaFg_(M0H;Z$L`OVAIj<-UxJx;2D2?MDAzf9Z7T%>@ zHMG{#j}Ye-afQ&O&KqhI9gh$%D`E@p(k>fX6G@NIt}9v#@6xU}Xcv!3ebgadY)XC9 zP(#2zLV8}2BD70)ZsJ8?z8bNi|ZGUcS7I^!M>QE*75gD<-CHYE3T*T;KlVFJcn@| zlC@bWd5z1MoSSV-GP5QmH7g@Iv%lpp%{nF2tTXZlE-5+1<(3F@dIv9aTr;vT>zth7 z!pSFG1UbPaC$RzkP3C5mWMx(upv|hu5wrhAxHRjM49&VK2mkmF0X~GEi5UO@6G)1( diff --git a/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.br b/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js.br deleted file mode 100644 index 682afec036b3f1276fb19020596574942cc1c5aa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3574 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 ZZcL*-jXL;RJ092n_!qPosohg50064nxvT&H diff --git a/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js b/apps/dashboard/build/_app/immutable/entry/app.Bv9rD2TH.js similarity index 79% rename from apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js rename to apps/dashboard/build/_app/immutable/entry/app.Bv9rD2TH.js index 319e17d..da09974 100644 --- a/apps/dashboard/build/_app/immutable/entry/app.BIXcLtMB.js +++ b/apps/dashboard/build/_app/immutable/entry/app.Bv9rD2TH.js @@ -1,2 +1,2 @@ -const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["../nodes/0.BSxKGxRx.js","../chunks/Bzak7iHL.js","../chunks/GG5zm9kr.js","../chunks/CpWkWWOo.js","../chunks/BlVfL1ME.js","../chunks/CHOnp4oo.js","../chunks/B4yTwGkE.js","../chunks/DdEqwvdI.js","../chunks/CGEBXrjl.js","../chunks/CJCPY1OL.js","../chunks/A7po6GxK.js","../chunks/aVbAZ-t7.js","../chunks/BKuqSeVd.js","../chunks/sZcqyNBA.js","../chunks/CJsMJEun.js","../chunks/C6HuKgyx.js","../chunks/BeMFXnHE.js","../chunks/D-gDZzN6.js","../chunks/DGcYlAAw.js","../chunks/MAY1QfFZ.js","../chunks/BUoSzNdg.js","../chunks/Cx-f-Pzo.js","../chunks/D4ymNiig.js","../chunks/CcUbQ_Wl.js","../chunks/554JRhq6.js","../assets/0.CN9L-NIY.css","../nodes/1.CJFfVX1H.js","../nodes/2.D-vKwnTC.js","../nodes/3.mK8D6pz1.js","../nodes/4.DPhwyLUO.js","../chunks/V6gjw5Ec.js","../nodes/5.C0AYWqwr.js","../chunks/BnXDGOmJ.js","../assets/5.DQ_AfUnN.css","../nodes/6.BD0AetaD.js","../chunks/C4h_mRt2.js","../assets/6.BSSBWVKL.css","../nodes/7.2YrTacps.js","../assets/7.CCrNEDd3.css","../nodes/8.CokrlgDp.js","../nodes/9.Vu2AXN40.js","../assets/9.BBx09UGv.css","../nodes/10.CjP_ylq3.js","../nodes/11.k15P8M2H.js","../nodes/12.BthmSU_R.js","../nodes/13.C0fh4g_5.js","../assets/13.Bjd0S47S.css","../nodes/14.DUh3SXOF.js","../nodes/15.QNRJhGzj.js","../assets/15.ChjqzJHo.css","../nodes/16.QhdtMP78.js","../assets/16.BnHgRQtR.css","../nodes/17.DlzXJVdF.js","../nodes/18.Bmu4OWRV.js","../nodes/19.Baocji37.js","../nodes/20.CJQuAMkU.js","../assets/20.DKhUrxcR.css"])))=>i.map(i=>d[i]); -var Q=r=>{throw TypeError(r)};var X=(r,t,e)=>t.has(r)||Q("Cannot "+e);var l=(r,t,e)=>(X(r,t,"read from private field"),e?e.call(r):t.get(r)),H=(r,t,e)=>t.has(r)?Q("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(r):t.set(r,e),W=(r,t,e,n)=>(X(r,t,"write to private field"),n?n.call(r,e):t.set(r,e),e);import{N as Z,ab as ut,b as _t,E as ct,ac as lt,ae as dt,T as ft,R as $,ax as vt,U as ht,h as U,L as pt,g as h,bc as Et,G as gt,I as Pt,p as Rt,aA as yt,aB as Ot,$ as At,f as L,e as Tt,a as bt,s as z,d as Lt,r as It,u as x,t as Dt}from"../chunks/CpWkWWOo.js";import{h as Vt,m as wt,u as kt,s as xt}from"../chunks/BlVfL1ME.js";import"../chunks/Bzak7iHL.js";import{o as St}from"../chunks/GG5zm9kr.js";import{i as B}from"../chunks/B4yTwGkE.js";import{a as g,c as V,f as et,t as jt}from"../chunks/CHOnp4oo.js";import{B as Ct}from"../chunks/DdEqwvdI.js";import{b as S}from"../chunks/CJsMJEun.js";import{p as N}from"../chunks/V6gjw5Ec.js";function j(r,t,e){var n;Z&&(n=ht,ut());var i=new Ct(r);_t(()=>{var c=t()??null;if(Z){var s=lt(n),a=s===vt,m=c!==null;if(a!==m){var R=dt();ft(R),i.anchor=R,$(!1),i.ensure(c,c&&(u=>e(u,c))),$(!0);return}}i.ensure(c,c&&(u=>e(u,c)))},ct)}function Bt(r){return class extends Nt{constructor(t){super({component:r,...t})}}}var P,d;class Nt{constructor(t){H(this,P);H(this,d);var c;var e=new Map,n=(s,a)=>{var m=Pt(a,!1,!1);return e.set(s,m),m};const i=new Proxy({...t.props||{},$$events:{}},{get(s,a){return h(e.get(a)??n(a,Reflect.get(s,a)))},has(s,a){return a===pt?!0:(h(e.get(a)??n(a,Reflect.get(s,a))),Reflect.has(s,a))},set(s,a,m){return U(e.get(a)??n(a,m),m),Reflect.set(s,a,m)}});W(this,d,(t.hydrate?Vt:wt)(t.component,{target:t.target,anchor:t.anchor,props:i,context:t.context,intro:t.intro??!1,recover:t.recover,transformError:t.transformError})),(!((c=t==null?void 0:t.props)!=null&&c.$$host)||t.sync===!1)&&Et(),W(this,P,i.$$events);for(const s of Object.keys(l(this,d)))s==="$set"||s==="$destroy"||s==="$on"||gt(this,s,{get(){return l(this,d)[s]},set(a){l(this,d)[s]=a},enumerable:!0});l(this,d).$set=s=>{Object.assign(i,s)},l(this,d).$destroy=()=>{kt(l(this,d))}}$set(t){l(this,d).$set(t)}$on(t,e){l(this,P)[t]=l(this,P)[t]||[];const n=(...i)=>e.call(this,...i);return l(this,P)[t].push(n),()=>{l(this,P)[t]=l(this,P)[t].filter(i=>i!==n)}}$destroy(){l(this,d).$destroy()}}P=new WeakMap,d=new WeakMap;const Ut="modulepreload",qt=function(r,t){return new URL(r,t).href},tt={},o=function(t,e,n){let i=Promise.resolve();if(e&&e.length>0){let s=function(u){return Promise.all(u.map(p=>Promise.resolve(p).then(y=>({status:"fulfilled",value:y}),y=>({status:"rejected",reason:y}))))};const a=document.getElementsByTagName("link"),m=document.querySelector("meta[property=csp-nonce]"),R=(m==null?void 0:m.nonce)||(m==null?void 0:m.getAttribute("nonce"));i=s(e.map(u=>{if(u=qt(u,n),u in tt)return;tt[u]=!0;const p=u.endsWith(".css"),y=p?'[rel="stylesheet"]':"";if(!!n)for(let O=a.length-1;O>=0;O--){const _=a[O];if(_.href===u&&(!p||_.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${u}"]${y}`))return;const E=document.createElement("link");if(E.rel=p?"stylesheet":Ut,p||(E.as="script"),E.crossOrigin="",E.href=u,R&&E.setAttribute("nonce",R),document.head.appendChild(E),p)return new Promise((O,_)=>{E.addEventListener("load",O),E.addEventListener("error",()=>_(new Error(`Unable to preload CSS for ${u}`)))})}))}function c(s){const a=new Event("vite:preloadError",{cancelable:!0});if(a.payload=s,window.dispatchEvent(a),!a.defaultPrevented)throw s}return i.then(s=>{for(const a of s||[])a.status==="rejected"&&c(a.reason);return t().catch(c)})},ae={};var Ft=et('

      '),Gt=et(" ",1);function Yt(r,t){Rt(t,!0);let e=N(t,"components",23,()=>[]),n=N(t,"data_0",3,null),i=N(t,"data_1",3,null),c=N(t,"data_2",3,null);yt(()=>t.stores.page.set(t.page)),Ot(()=>{t.stores,t.page,t.constructors,e(),t.form,n(),i(),c(),t.stores.page.notify()});let s=z(!1),a=z(!1),m=z(null);St(()=>{const _=t.stores.page.subscribe(()=>{h(s)&&(U(a,!0),At().then(()=>{U(m,document.title||"untitled page",!0)}))});return U(s,!0),_});const R=x(()=>t.constructors[2]);var u=Gt(),p=L(u);{var y=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params},children:(f,Wt)=>{var K=V(),at=L(K);{var st=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params},children:(v,zt)=>{var M=V(),nt=L(M);j(nt,()=>h(R),(it,mt)=>{S(mt(it,{get data(){return c()},get form(){return t.form},get params(){return t.page.params}}),C=>e()[2]=C,()=>{var C;return(C=e())==null?void 0:C[2]})}),g(v,M)},$$slots:{default:!0}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)},ot=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)};B(at,D=>{t.constructors[2]?D(st):D(ot,!1)})}g(f,K)},$$slots:{default:!0}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)},J=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)};B(p,_=>{t.constructors[1]?_(y):_(J,!1)})}var E=Tt(p,2);{var O=_=>{var A=Ft(),T=Lt(A);{var w=b=>{var I=jt();Dt(()=>xt(I,h(m))),g(b,I)};B(T,b=>{h(a)&&b(w)})}It(A),g(_,A)};B(E,_=>{h(s)&&_(O)})}g(r,u),bt()}const se=Bt(Yt),oe=[()=>o(()=>import("../nodes/0.BSxKGxRx.js"),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]),import.meta.url),()=>o(()=>import("../nodes/1.CJFfVX1H.js"),__vite__mapDeps([26,1,20,3,4,5,18,2,16,17]),import.meta.url),()=>o(()=>import("../nodes/2.D-vKwnTC.js"),__vite__mapDeps([27,1,3,5,9,7]),import.meta.url),()=>o(()=>import("../nodes/3.mK8D6pz1.js"),__vite__mapDeps([28,1,20,3,2,17,16,18]),import.meta.url),()=>o(()=>import("../nodes/4.DPhwyLUO.js"),__vite__mapDeps([29,1,2,3,4,5,6,7,10,13,24,19,16,8,30,15,23]),import.meta.url),()=>o(()=>import("../nodes/5.C0AYWqwr.js"),__vite__mapDeps([31,1,3,4,5,6,7,8,11,12,21,32,10,30,15,16,33]),import.meta.url),()=>o(()=>import("../nodes/6.BD0AetaD.js"),__vite__mapDeps([34,1,3,4,5,6,7,8,35,10,11,12,24,21,30,15,16,18,2,36]),import.meta.url),()=>o(()=>import("../nodes/7.2YrTacps.js"),__vite__mapDeps([37,1,2,3,4,5,6,7,8,10,13,11,12,21,23,38]),import.meta.url),()=>o(()=>import("../nodes/8.CokrlgDp.js"),__vite__mapDeps([39,1,3,4,5,6,7,8,10,11,12,21,13,24]),import.meta.url),()=>o(()=>import("../nodes/9.Vu2AXN40.js"),__vite__mapDeps([40,1,20,3,4,5,6,7,8,21,12,15,16,19,23,10,11,30,41]),import.meta.url),()=>o(()=>import("../nodes/10.CjP_ylq3.js"),__vite__mapDeps([42,1,2,3,4,5,6,7,8,10,11,12,21,13,32,15,16,18,14,30,23,20,24,19]),import.meta.url),()=>o(()=>import("../nodes/11.k15P8M2H.js"),__vite__mapDeps([43,1,2,3,4,5,6,7,8,21,12,13,17,16,18,24,23,10,30,15]),import.meta.url),()=>o(()=>import("../nodes/12.BthmSU_R.js"),__vite__mapDeps([44,1,2,3,4,5,6,7,8,11,12,24]),import.meta.url),()=>o(()=>import("../nodes/13.C0fh4g_5.js"),__vite__mapDeps([45,1,2,3,4,5,6,7,8,10,11,12,21,13,32,24,23,46]),import.meta.url),()=>o(()=>import("../nodes/14.DUh3SXOF.js"),__vite__mapDeps([47,1,2,3,4,5,6,7,8,10,11,12,21]),import.meta.url),()=>o(()=>import("../nodes/15.QNRJhGzj.js"),__vite__mapDeps([48,1,2,3,4,5,6,7,8,35,10,21,12,13,14,24,11,30,15,16,23,49]),import.meta.url),()=>o(()=>import("../nodes/16.QhdtMP78.js"),__vite__mapDeps([50,1,2,3,4,5,6,7,8,11,12,24,10,21,30,15,16,23,51]),import.meta.url),()=>o(()=>import("../nodes/17.DlzXJVdF.js"),__vite__mapDeps([52,1,2,3,4,5,6,7,8,11,12,21,15,16,24,19,22,23]),import.meta.url),()=>o(()=>import("../nodes/18.Bmu4OWRV.js"),__vite__mapDeps([53,1,2,3,4,5,6,7,8,21,12,24]),import.meta.url),()=>o(()=>import("../nodes/19.Baocji37.js"),__vite__mapDeps([54,1,2,3,4,5,6,7,8,21,12,32,24,23]),import.meta.url),()=>o(()=>import("../nodes/20.CJQuAMkU.js"),__vite__mapDeps([55,1,2,3,4,5,6,7,8,35,10,11,12,21,13,32,14,18,16,56]),import.meta.url)],ne=[],ie={"/":[3],"/(app)/activation":[4,[2]],"/(app)/contradictions":[5,[2]],"/(app)/dreams":[6,[2]],"/(app)/duplicates":[7,[2]],"/(app)/explore":[8,[2]],"/(app)/feed":[9,[2]],"/(app)/graph":[10,[2]],"/(app)/importance":[11,[2]],"/(app)/intentions":[12,[2]],"/(app)/memories":[13,[2]],"/(app)/patterns":[14,[2]],"/(app)/reasoning":[15,[2]],"/(app)/schedule":[16,[2]],"/(app)/settings":[17,[2]],"/(app)/stats":[18,[2]],"/(app)/timeline":[19,[2]],"/waitlist":[20]},rt={handleError:(({error:r})=>{console.error(r)}),reroute:(()=>{}),transport:{}},Ht=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.decode])),me=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.encode])),ue=!1,_e=(r,t)=>Ht[r](t);export{_e as decode,Ht as decoders,ie as dictionary,me as encoders,ue as hash,rt as hooks,ae as matchers,oe as nodes,se as root,ne as server_loads}; +const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["../nodes/0.j0CpgSFp.js","../chunks/Bzak7iHL.js","../chunks/GG5zm9kr.js","../chunks/CpWkWWOo.js","../chunks/BlVfL1ME.js","../chunks/CHOnp4oo.js","../chunks/B4yTwGkE.js","../chunks/DdEqwvdI.js","../chunks/CGEBXrjl.js","../chunks/CJCPY1OL.js","../chunks/A7po6GxK.js","../chunks/aVbAZ-t7.js","../chunks/BKuqSeVd.js","../chunks/sZcqyNBA.js","../chunks/CJsMJEun.js","../chunks/C6HuKgyx.js","../chunks/BeMFXnHE.js","../chunks/C2TQQEIa.js","../chunks/D8UfWY0j.js","../chunks/MAY1QfFZ.js","../chunks/BUoSzNdg.js","../chunks/Cx-f-Pzo.js","../chunks/D4ymNiig.js","../chunks/CcUbQ_Wl.js","../chunks/B7CfdQuM.js","../assets/0.Bor8S3Zo.css","../nodes/1.DEUqmURt.js","../nodes/2.D-vKwnTC.js","../nodes/3.Bu_uPddU.js","../nodes/4.DYVet_v-.js","../chunks/V6gjw5Ec.js","../nodes/5.C0AYWqwr.js","../chunks/BnXDGOmJ.js","../assets/5.DQ_AfUnN.css","../nodes/6.54m-BxV_.js","../chunks/C4h_mRt2.js","../assets/6.BSSBWVKL.css","../nodes/7.2YrTacps.js","../assets/7.CCrNEDd3.css","../nodes/8.DGKslLJe.js","../nodes/9.Vu2AXN40.js","../assets/9.BBx09UGv.css","../nodes/10.CACwABbv.js","../nodes/11.B_W3XFQr.js","../nodes/12.DxkSrFsy.js","../nodes/13.CD5qzYsO.js","../assets/13.Bjd0S47S.css","../nodes/14.DUh3SXOF.js","../nodes/15.CyCv1LGV.js","../assets/15.ChjqzJHo.css","../nodes/16.Cth-SSqa.js","../assets/16.BnHgRQtR.css","../nodes/17.k6k7874Y.js","../nodes/18.C60Wuzj2.js","../nodes/19.BIUSI5ln.js","../nodes/20.DebghJca.js","../assets/20.DKhUrxcR.css"])))=>i.map(i=>d[i]); +var Q=r=>{throw TypeError(r)};var X=(r,t,e)=>t.has(r)||Q("Cannot "+e);var l=(r,t,e)=>(X(r,t,"read from private field"),e?e.call(r):t.get(r)),H=(r,t,e)=>t.has(r)?Q("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(r):t.set(r,e),W=(r,t,e,n)=>(X(r,t,"write to private field"),n?n.call(r,e):t.set(r,e),e);import{N as Z,ab as ut,b as _t,E as ct,ac as lt,ae as dt,T as ft,R as $,ax as vt,U as ht,h as U,L as pt,g as h,bc as Et,G as gt,I as Pt,p as Rt,aA as yt,aB as Ot,$ as At,f as L,e as Tt,a as bt,s as z,d as Lt,r as It,u as x,t as Dt}from"../chunks/CpWkWWOo.js";import{h as Vt,m as wt,u as kt,s as xt}from"../chunks/BlVfL1ME.js";import"../chunks/Bzak7iHL.js";import{o as St}from"../chunks/GG5zm9kr.js";import{i as B}from"../chunks/B4yTwGkE.js";import{a as g,c as V,f as et,t as jt}from"../chunks/CHOnp4oo.js";import{B as Ct}from"../chunks/DdEqwvdI.js";import{b as S}from"../chunks/CJsMJEun.js";import{p as N}from"../chunks/V6gjw5Ec.js";function j(r,t,e){var n;Z&&(n=ht,ut());var i=new Ct(r);_t(()=>{var c=t()??null;if(Z){var s=lt(n),a=s===vt,m=c!==null;if(a!==m){var R=dt();ft(R),i.anchor=R,$(!1),i.ensure(c,c&&(u=>e(u,c))),$(!0);return}}i.ensure(c,c&&(u=>e(u,c)))},ct)}function Bt(r){return class extends Nt{constructor(t){super({component:r,...t})}}}var P,d;class Nt{constructor(t){H(this,P);H(this,d);var c;var e=new Map,n=(s,a)=>{var m=Pt(a,!1,!1);return e.set(s,m),m};const i=new Proxy({...t.props||{},$$events:{}},{get(s,a){return h(e.get(a)??n(a,Reflect.get(s,a)))},has(s,a){return a===pt?!0:(h(e.get(a)??n(a,Reflect.get(s,a))),Reflect.has(s,a))},set(s,a,m){return U(e.get(a)??n(a,m),m),Reflect.set(s,a,m)}});W(this,d,(t.hydrate?Vt:wt)(t.component,{target:t.target,anchor:t.anchor,props:i,context:t.context,intro:t.intro??!1,recover:t.recover,transformError:t.transformError})),(!((c=t==null?void 0:t.props)!=null&&c.$$host)||t.sync===!1)&&Et(),W(this,P,i.$$events);for(const s of Object.keys(l(this,d)))s==="$set"||s==="$destroy"||s==="$on"||gt(this,s,{get(){return l(this,d)[s]},set(a){l(this,d)[s]=a},enumerable:!0});l(this,d).$set=s=>{Object.assign(i,s)},l(this,d).$destroy=()=>{kt(l(this,d))}}$set(t){l(this,d).$set(t)}$on(t,e){l(this,P)[t]=l(this,P)[t]||[];const n=(...i)=>e.call(this,...i);return l(this,P)[t].push(n),()=>{l(this,P)[t]=l(this,P)[t].filter(i=>i!==n)}}$destroy(){l(this,d).$destroy()}}P=new WeakMap,d=new WeakMap;const Ut="modulepreload",qt=function(r,t){return new URL(r,t).href},tt={},o=function(t,e,n){let i=Promise.resolve();if(e&&e.length>0){let s=function(u){return Promise.all(u.map(p=>Promise.resolve(p).then(y=>({status:"fulfilled",value:y}),y=>({status:"rejected",reason:y}))))};const a=document.getElementsByTagName("link"),m=document.querySelector("meta[property=csp-nonce]"),R=(m==null?void 0:m.nonce)||(m==null?void 0:m.getAttribute("nonce"));i=s(e.map(u=>{if(u=qt(u,n),u in tt)return;tt[u]=!0;const p=u.endsWith(".css"),y=p?'[rel="stylesheet"]':"";if(!!n)for(let O=a.length-1;O>=0;O--){const _=a[O];if(_.href===u&&(!p||_.rel==="stylesheet"))return}else if(document.querySelector(`link[href="${u}"]${y}`))return;const E=document.createElement("link");if(E.rel=p?"stylesheet":Ut,p||(E.as="script"),E.crossOrigin="",E.href=u,R&&E.setAttribute("nonce",R),document.head.appendChild(E),p)return new Promise((O,_)=>{E.addEventListener("load",O),E.addEventListener("error",()=>_(new Error(`Unable to preload CSS for ${u}`)))})}))}function c(s){const a=new Event("vite:preloadError",{cancelable:!0});if(a.payload=s,window.dispatchEvent(a),!a.defaultPrevented)throw s}return i.then(s=>{for(const a of s||[])a.status==="rejected"&&c(a.reason);return t().catch(c)})},ae={};var Ft=et('
      '),Gt=et(" ",1);function Yt(r,t){Rt(t,!0);let e=N(t,"components",23,()=>[]),n=N(t,"data_0",3,null),i=N(t,"data_1",3,null),c=N(t,"data_2",3,null);yt(()=>t.stores.page.set(t.page)),Ot(()=>{t.stores,t.page,t.constructors,e(),t.form,n(),i(),c(),t.stores.page.notify()});let s=z(!1),a=z(!1),m=z(null);St(()=>{const _=t.stores.page.subscribe(()=>{h(s)&&(U(a,!0),At().then(()=>{U(m,document.title||"untitled page",!0)}))});return U(s,!0),_});const R=x(()=>t.constructors[2]);var u=Gt(),p=L(u);{var y=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params},children:(f,Wt)=>{var K=V(),at=L(K);{var st=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params},children:(v,zt)=>{var M=V(),nt=L(M);j(nt,()=>h(R),(it,mt)=>{S(mt(it,{get data(){return c()},get form(){return t.form},get params(){return t.page.params}}),C=>e()[2]=C,()=>{var C;return(C=e())==null?void 0:C[2]})}),g(v,M)},$$slots:{default:!0}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)},ot=D=>{const q=x(()=>t.constructors[1]);var k=V(),F=L(k);j(F,()=>h(q),(G,Y)=>{S(Y(G,{get data(){return i()},get form(){return t.form},get params(){return t.page.params}}),v=>e()[1]=v,()=>{var v;return(v=e())==null?void 0:v[1]})}),g(D,k)};B(at,D=>{t.constructors[2]?D(st):D(ot,!1)})}g(f,K)},$$slots:{default:!0}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)},J=_=>{const A=x(()=>t.constructors[0]);var T=V(),w=L(T);j(w,()=>h(A),(b,I)=>{S(I(b,{get data(){return n()},get form(){return t.form},get params(){return t.page.params}}),f=>e()[0]=f,()=>{var f;return(f=e())==null?void 0:f[0]})}),g(_,T)};B(p,_=>{t.constructors[1]?_(y):_(J,!1)})}var E=Tt(p,2);{var O=_=>{var A=Ft(),T=Lt(A);{var w=b=>{var I=jt();Dt(()=>xt(I,h(m))),g(b,I)};B(T,b=>{h(a)&&b(w)})}It(A),g(_,A)};B(E,_=>{h(s)&&_(O)})}g(r,u),bt()}const se=Bt(Yt),oe=[()=>o(()=>import("../nodes/0.j0CpgSFp.js"),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25]),import.meta.url),()=>o(()=>import("../nodes/1.DEUqmURt.js"),__vite__mapDeps([26,1,20,3,4,5,18,2,16,17]),import.meta.url),()=>o(()=>import("../nodes/2.D-vKwnTC.js"),__vite__mapDeps([27,1,3,5,9,7]),import.meta.url),()=>o(()=>import("../nodes/3.Bu_uPddU.js"),__vite__mapDeps([28,1,20,3,2,17,16,18]),import.meta.url),()=>o(()=>import("../nodes/4.DYVet_v-.js"),__vite__mapDeps([29,1,2,3,4,5,6,7,10,13,24,19,16,8,30,15,23]),import.meta.url),()=>o(()=>import("../nodes/5.C0AYWqwr.js"),__vite__mapDeps([31,1,3,4,5,6,7,8,11,12,21,32,10,30,15,16,33]),import.meta.url),()=>o(()=>import("../nodes/6.54m-BxV_.js"),__vite__mapDeps([34,1,3,4,5,6,7,8,35,10,11,12,24,21,30,15,16,18,2,36]),import.meta.url),()=>o(()=>import("../nodes/7.2YrTacps.js"),__vite__mapDeps([37,1,2,3,4,5,6,7,8,10,13,11,12,21,23,38]),import.meta.url),()=>o(()=>import("../nodes/8.DGKslLJe.js"),__vite__mapDeps([39,1,3,4,5,6,7,8,10,11,12,21,13,24]),import.meta.url),()=>o(()=>import("../nodes/9.Vu2AXN40.js"),__vite__mapDeps([40,1,20,3,4,5,6,7,8,21,12,15,16,19,23,10,11,30,41]),import.meta.url),()=>o(()=>import("../nodes/10.CACwABbv.js"),__vite__mapDeps([42,1,2,3,4,5,6,7,8,10,11,12,21,13,32,15,16,18,14,30,23,20,24,19]),import.meta.url),()=>o(()=>import("../nodes/11.B_W3XFQr.js"),__vite__mapDeps([43,1,2,3,4,5,6,7,8,21,12,13,17,16,18,24,23,10,30,15]),import.meta.url),()=>o(()=>import("../nodes/12.DxkSrFsy.js"),__vite__mapDeps([44,1,2,3,4,5,6,7,8,11,12,24]),import.meta.url),()=>o(()=>import("../nodes/13.CD5qzYsO.js"),__vite__mapDeps([45,1,2,3,4,5,6,7,8,10,11,12,21,13,32,24,23,46]),import.meta.url),()=>o(()=>import("../nodes/14.DUh3SXOF.js"),__vite__mapDeps([47,1,2,3,4,5,6,7,8,10,11,12,21]),import.meta.url),()=>o(()=>import("../nodes/15.CyCv1LGV.js"),__vite__mapDeps([48,1,2,3,4,5,6,7,8,35,10,21,12,13,14,24,11,30,15,16,23,49]),import.meta.url),()=>o(()=>import("../nodes/16.Cth-SSqa.js"),__vite__mapDeps([50,1,2,3,4,5,6,7,8,11,12,24,10,21,30,15,16,23,51]),import.meta.url),()=>o(()=>import("../nodes/17.k6k7874Y.js"),__vite__mapDeps([52,1,2,3,4,5,6,7,8,11,12,21,15,16,24,19,22,23]),import.meta.url),()=>o(()=>import("../nodes/18.C60Wuzj2.js"),__vite__mapDeps([53,1,2,3,4,5,6,7,8,21,12,24]),import.meta.url),()=>o(()=>import("../nodes/19.BIUSI5ln.js"),__vite__mapDeps([54,1,2,3,4,5,6,7,8,21,12,32,24,23]),import.meta.url),()=>o(()=>import("../nodes/20.DebghJca.js"),__vite__mapDeps([55,1,2,3,4,5,6,7,8,35,10,11,12,21,13,32,14,18,16,56]),import.meta.url)],ne=[],ie={"/":[3],"/(app)/activation":[4,[2]],"/(app)/contradictions":[5,[2]],"/(app)/dreams":[6,[2]],"/(app)/duplicates":[7,[2]],"/(app)/explore":[8,[2]],"/(app)/feed":[9,[2]],"/(app)/graph":[10,[2]],"/(app)/importance":[11,[2]],"/(app)/intentions":[12,[2]],"/(app)/memories":[13,[2]],"/(app)/patterns":[14,[2]],"/(app)/reasoning":[15,[2]],"/(app)/schedule":[16,[2]],"/(app)/settings":[17,[2]],"/(app)/stats":[18,[2]],"/(app)/timeline":[19,[2]],"/waitlist":[20]},rt={handleError:(({error:r})=>{console.error(r)}),reroute:(()=>{}),transport:{}},Ht=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.decode])),me=Object.fromEntries(Object.entries(rt.transport).map(([r,t])=>[r,t.encode])),ue=!1,_e=(r,t)=>Ht[r](t);export{_e as decode,Ht as decoders,ie as dictionary,me as encoders,ue as hash,rt as hooks,ae as matchers,oe as nodes,se as root,ne as server_loads}; diff --git a/apps/dashboard/build/_app/immutable/entry/app.Bv9rD2TH.js.br b/apps/dashboard/build/_app/immutable/entry/app.Bv9rD2TH.js.br new file mode 100644 index 0000000000000000000000000000000000000000..3a1c082afb8001ea1db59c0ac6323def3d27d818 GIT binary patch literal 3598 zcmV+p4)O6DQYs>fQ#aYrbY@wSPg@ zv%bzCoea7&0Bdi~$U*81Rcat=x)c=^UE0b}+YrG@C|c9|wq;B;R`=XjFa*8{{%zSZ z`8J3fbx-Z!SU$Zbl@p?1qHsng#7w@u!cJ1tm`X@_b`@Lp)u7tdo7Km?3!(UD+MSOF zuHtX-;DomOo!Gi_H|*>n#9+EQtX8Aa_J_;74_~5rX55c>by$WE*Yi{BAcn2zcv`d` z?BFi)*J3|}=wmS6z_-5WolMK))^kt9-xKfggE|rYCw;7wWhTns>2dw)dvfq72i-{X z=<&Vo?anLPw}a-Iw}HZ~1Ct_wB*O27cttM>FEz%Gt{>+r?KO^7437 zUN~H{S4yGZTqKitHH7KORi1t5K}F`5iY@*`oX(uz<;T>$R=B%?65cG1?Auf|i{e1B za{YATUjxVye;(`iEc@1g4GDiOiE7m4FKc<+*)NZx^Z~mPR4+EG<7qZ@$Lp{)VqLp{ zu7n@4*Iw{p1AZ1aMj!muGR7wchuxTcDztvKZhhvjmc2dzUj+Tc9H&z^U#gnHl^8~0 z<^c3n!n>Y)dhQa70^ejgN8Wnas3OdV>0dtE-@dhKpdd|f5u7|fse2Nt@f)jypUsJA zK{Mg%P!~;kZXh?owfpbommHCigYEaT>a1~6AHXo-x5AmNN6iLE6Rd+8_FGGw)%Lsl zf1Ag42~e3pi}I{~#B*kA`{VX*I#E*q+Z>J$U%s9k{-R_|_qh5)zx4N2p*8-)V%Bko zynzr+Xp>I&F@3M$@Kh|sa}&O0%q(%wuzX5X;#NvCj&kEj-fJR4;zD(2lcjK4ULL+$ zu#dhrS_=?RAV2utYKq*E;O%un=2gze6AjEaVZCinW3(Q%<`Jo>MN+wy$wds3kgHa* zk>Hv#JFES97;WQrOS)OO)v6y6BgKqaa|2+@nKQYjY6E1G_TK-utP_kc=o3(<)JYs2vn|a{RVx;(;6<@Ozw1?sozhK6nxhfpt-E%L4jc1|O*4Gan{&Z0*~s1k^KAYo`XC*f zb6h713B?OCV0|v?j=tAWJVQYd>Z_j)lR3xEz>B+<`ko~xEXlzT|2)w7xCW}U5E#PC zWQL3`KxplpdcUKK0vb3jcStRO?vxX?x@fP<7$I;!3AEG23k^K+vyRT-HSkI_4D+Bg zD#`hMaK@tR7xCz^bPu?66zMi${A=XdQzin$nbG{!RNX!18lob)3Gc?B*cft!t)yeq&k;MR)*j-(hjNU)Om z$Smb2tBz;oYE2iy;J9oOceWs1+}_@bqt!029+%zxDYkfB5HZs&_PUBN{u&Qsz2Iz+ zj0W@l7qN&;H8JcDK%plqOn?+EF$;sC-P-~eSgm*Hn33dtT?W4fFqBZnW<5{37> zCbz4^OdV0zE61cj`m>BVRhdkX>;rVD58*-|jp?z(1qS&JlXbib=EkM=f-}e((h$7T z9Z(Lky#x(tRu}isH#86Kb=`>hD8E@@eLh(mi2O=5bZ`ZW2eTO^iRm4V^9k zvT7jKtm2E9v*au>UGD!=-)zr^M}F#XesHfodxkExA6V#+jwoyo z{TU3VS8`_3`Y!FyPUgsJp6&`|QPWM!e9wsI5;CR&SR@@|M#J;)_WBZ>5w$ZPn}^I1 z6-UHjn4VG4cKW6Nlr%U)2Xq`LWj5tjN>iQ5j%~f7lKHU~!4;QuW*HmY=e4KFL&{=b zlzpk0p|913!8sKG@2Wv z)%L1C13TF^M~TQV>F{4*sv9D*)(vw^pD!}fZ{}mlpab|-A!F(t5u@VR6o>Ie1V)JC z{@$Zn_uh972}jldSaA_3{a+DB#p+%V)Mxxxa6tPftVd_FTrxc+>2c_n z$lSv1fL)f<@c0`8_qd#Vv`&L%iK;eLzSdWX1Fx>kdX6!S$d+P;fv?SpUJ=yuvRg-b zckwhfGr3!l<#23e^4jIx#NcO$$nzSd`;@SW$U1#36c$fnj^0&JyNEL^{-zpT;& zd->em!VcAzS5|t)EDSDz30z$)wg2L%R4TwX?(~|%pn+`K28&e6UPkRzs>!sQkq&#d zy0A?p`}yu!!In>f5SIG3vq~=i<4AO?1mTjg>B{Fph?{QFeD*ycS2zN%2;={aeSr49 zFj`hNCN{zQ6(Qg$cIO*S-xp04C=_QQhM$SZD=C*_7=Q{CkTbX_w4&Vm1Jk<}stj_b5nm=^iWyyIvojf~*L2JYzvD zDUe+2#oMbnACK8q9d;Yent7&7mq?vNXJU+Glv8;|Il$)K6y2iy94&Wht5@<&nxpdj ztg|#Mu^%3WOYIqRS$gZl=H;GF-n?m-JO)V6vB=^XbtoyM!G*PN6a;FrJe0uo8-Tun zUnngJo~1*g(o~PLbzBB=taRza^~jonwIw}E&6g_I{XIBd3NJpin*4BSvvs_sh0W7$ zsCEC-Nw?Q{xp=_29kd;;eQUaeDwsZJOs7yE_iOrKqj#&c2r})i*$t?PCAu}L*n1}j2b(GZHvq5yQ^=jQ+Q*D!}+lEyPXLeirvi$Dy+w#=DF@8Tk|8-N0U2kD<{^zL> zcMMLC!P%=AbUQ%5RU~r-6;Mi4jU+a=@T8gUvU#Pz>#LLe)p27-_IVU$ChxIQ>YyOT zObIv@KsiT}g|u*y(8*N$fKL*8vBx5v%XDKf3J@P6pc#ph<(I_Y+sdVajan$Jq^Oy0 zVlv)7=AmSnM`Or9|1z|-0fFG40T-X~1z+(EkbnwkfDRad30Qy)IDiX8AO$iY2MVCf z7-s+7hFQ&xo(&mfk)p0)AVbxA_F%9_H0(^XLdh8otfP2KU3>%nQ20heGWGxqxPHAa zCzRvSu($QU4AR$Hh;RKB4u_M7-1JZ&NW+zm2H^&S%p9a}rlr{k2i5rs<%cwg;xH$} zECk6^DZt=!5}kSp#f~&^CyY1f`Y|C)neR+54<(m0aA$zQ`UU-dCqgI^r6F%HAO~L- zwXqwsbxw+O_>^&15H0bJ0F}zT%#r1GzIs#cdC)0xSR$)L;}EE@H8BsOK(P+LLwehS3_w&4fn_rH5+r9lZ7mYp=%7#6wonk=ZEsJ4gzi7JqR7R zcjil2w}FOZx*61{q|L?4^A_CL_4_k$E9pN_D}`AxYg^~StN=Wnas@ZFx7hvYnQGex zw&<#373{__KNxpM;L3WEpeFdNt6M@V_@Zh)Mj`kL6#=6Ve2b4qB5Fs0>>HICL4!bb z-AnES79YZtvrht#>q$-!1ac0G-ncUeGOk()t)Sw{h!aFzYOXJWfm(@BWf9=Ah5DK! z`%0%!rKtUhGQJ)F7cw$cc;?iy$OQ@OCu~1=CuoX}lOZYXpQX0hBY_1>+P71Q@3CbioGo6&aLHG*RrM7m-VS5EaXy{ z$-sZqZl3bj8TpTP1ApiA{UQxF9y&+Ax7cn*o{RXcK_9F%Jo;_EjjpOkS-#QFANAPF zz<18#i{9uxL!bUU`Q@Eu?NhkFy{(@c89VGXyN^$~mo)t6(Nq4md-6L&zv(wVuB={$ z{`*#U>*gb4|Krlgy|V4>e6!iPZ9iu0T-~j8t=stL3~odbWf)miKiq2+fBTvlB`6Vd zdF{B~d~=(3Y_>)q3fl43;9}_A*HVb0R*l>7jb$}ch>~{v^gvmAu$30;VW;;p+^(Cc z1>0IJcl7l5Hq69t)%$gPdhPy5>#?mJ-?opsP46nL$BwpLa<{7Q5ABStO8vHb#|mj$ zJ6g5Ts6IYiT&8L5YK5op-Y|nGy=GUd)xxX#u~kg3+0%|sFCypi2TdutuRX+tqhD90 zT$W_7aPB>Ptx?jZ=>2Ee|h?lp$Dk`%iG6~vuvR4Xf@W~ zYBb)A%qnn&ch+are=_xJ6o>tq*J;om|g){~Xd){oEZ#!N(rgPdc z?ezLT%!~|(y688pFQdLzyur;XJime}5&vr|#{4p>>=~fT*gE8xe{!qFf1+*T9 zeyD`%q=MLAx)KsbC@f}L--rP5`FX3zHN*3KCdvOxRX)#|&r^Q!p&U}flDeVqNC2|c8mX*doLD>JP}84Of%mSuG~=VVxx#QIc<442Lby43B^P;&i{0@Cm# z-!rKUL?s(`F9TluuJlNa*9K*WOamH%WrQq&6M0N{5^q89VF=rs#Qcoh-l3Ps4Qm(4 zfDvpr@IyAfl8i|DO^gmcV@CM1%}5=eCL@N40|y2a2Nomu`0O%rhtEx7yyJ7gNE4rZ zM*8?{l1qF9jPy8|bU2+lBd7T6F>;R28%6?r-U0n19E@O4#lbZroA^9pq>Il>!uj6= z9-kdXB7A-ji(?rH@p;ZjjL&z%@Nvv0=+7@U=BWv|zz>YL_#7q_UK0lI84`znQNJ;i><|U zDi4ZAhUmiPKAp+Ed6k~Ixc^kTv1c;d_oSC3ea4uNUgh_-(X8M>ds>JOZc}#UWKpVuDPuen6F&m{5>#LQbuOl*OSpnS4EQLQJMk zW|~$}gRxj9nGTdZiM})HSzs$RHnDRJW0OG{W9m4H0~#s-1&eyrW95)&n#LyTWHLeF zZ-`Y9G_q^Y6xO#Ra-&v~ktGai^8YC}=T9Rbo~}g1n3~hoZ|9<%lG^GLrg#resFeTYc(Lv?rOXu?^6SeY~Sdb_{ zbYz84SPvgqdB{`%%)CR!%m{%bR97(|BAVb`30a$3h?8`Sb7) z>>pCoA5dJJj0g)2FY5ZC%eOh?vILlb=E{bmKt_m2KOFeBCFRPAYt#)6{r1h&HaGiz z#9%iBMMs_q#szPG`&NfcAc?Lw5c^X2=!u@hDOJs<&7M;W`@_0 zF{Jy!IFSz0!tQx+>Wjet3)2#rbY4PU*@6O-3DUsiS*8k*35c%n3gt}m>Y26l#h1^| z=T?#&kW-KnHZVw<1wM;|D$C09m0A!-eJod8q%Rq0UE5($51LUU+X&2cYw<0SwaIkZ^{v>UK}a3nuw?Sa^l81qx;%3bE^gjka+uZ+X?H>x(;?yg z`Fzokj2((40?LDHM-(DB@|^*NIt#^@e)~o>hk8BMKgfxh(R_V8<2GH4_KSJ*7w89R zih-&@XXPm)Xo1GiHnBJ=%iY)kQ#lk=85mAX%cF@(mS%($Lj)&4rx*Di&cMQx*u>B+ z--I~xcv-1C6o*lDbZ_*opoddr$M#;KsdDG@-eMY#8Wf8MdG9j~EN>PRxL>Cz?dCqaH#1LZiS|GX|^1`Wu5C2ZAVu z22x^76=tk3_8hnLja;HypvM~SHjg&zD>Cn|(Kf;1pU>caU5?nup;4bg61V;=%QAXw zW5ZLi0-&p|bt7@!R=#q5pyw*rTU)Bwe5AH+JYTnPNt?$9fd2<|3)q2N|QxWtokx98f^tBisR4U zO%KbXI0W#FmTHZL1P+wYczIPi5tVMqMx)n|LyD=Jgl5 zDJ?KYI7g4j(Dp2Us9AOt7|iSoLWW8<49%ilBX-zL$Tt;gsp8xgO%j{fB9pO#&$k-` zx0?t{t7>Q>dohS+`3t)l@E1uutF5r7K-mTMiixVic?F6TZ+lLd4(0sMzbtzo*%o+v zK%t~=;V})2K|@(GLfhDK>;ctfJdTD8h6&VQ;4o8{p~(Uek04zR{K!TlmL;PDB?+RT zB003n%2KWZE(rM3bZi*FKF*Y!#Q&%QxCK_~m+{00Vr}RC2f(=1cO8FNmio43QLiEm z`{0KyFsMn(lIIUYsNK@gws2)Wc&|u(YWMn#zsLuFZ5;gd9rQc+QzfTdT^T?U{F4c^ zbTg+vF;Uy^V0$Cj%3^j?{R-aXSxW;4^FonF7&ri0MUJ%$X0&rMDH1GI&?GN_^K-Dd z04~hHm62%Pq4R*$rV+$WPxP0J521;B+bZQ*aitP3Sg}R2x7-gggB`G1Q{g&xMv~<7534yR|^S zge|ked-svvo+)s&dUY;YeXl>j;vp=)S1T{dkh{3A96<}xA?K(>Lpg^bHfR!haNebX zttSM*X!$u4Q1t!Ibh~1?2%uPADIfSD@_wmpJ$z(Y8`m3`UN5VN0d-;jse8 zvGTFvGdy?0svhLV#n-m)3TbjJy*rntJC&xpLYgj2PNZp*d!YQ|zoT0GBg%s51Jce~ zKHoZQDRQN78lup27S=QiZO$p>TAhpJ2_s*Do0;FR(+slVH#F7yOcREH;vN zrks<$;^Oy+9yb$8aZfsY`!Hbp=qN+vc#gEVphtX4oeL^i>@UmrpUQKN*c${Rjf-X*2V34yka=! z=iGVd6nEAXVfo5&l?c0;oDr6vSphPmxURdGZ!K4`-A@}mH|NOxz9z@z>(CV(OS#2F z6if@EFbMnZqozU(FnTG!ZY5a0TU{kVVWp`Tv@RCr&W2hAVqjUyi7Z%Gp5+_eRq_-w z@)Ty3a(5bYrNk^e5Z9Gq`R;g?45h41lIUNT*Ya)jDqh?Ff&GQPrFHWxb*sIK`|kh6 zeO-3TSLLhN?Pb`B;!;@H3^A@2N(?H#c9<<+zps#FJNKoF6L}T|*k0Qd%QyL}1SotZ zKz_=X?=rj#SeN_quLV|d|0>JYkMQN+AFSe4`hwRqu-EN6mVeiz9H$lnzs2-NR}$?)>u_C0`?2pllxIJ|HQ4a?>qfg-?f zFXQ1D3vD;RcT(^;aBS0H6mh%DIQkwqen*E6OkS7CSuUkAT~iIfCHlh-i0M#NPrzfe$~ zL&944$q$~IMNNq77Mx;S`VWw!-jrNS^^H7fQ~oO!K%cSau%$4y0?~v&A83monQ-=? z%KRmaAn5t42x21~fo%Lo4_<Z`e0Q)^!?W;`Q3_(Uxsm(&tG}kl8BE(9}eIi aA4W7B(6Ei4wWCSpkADHL)4W_$DgXciKH1Fx literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js b/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js deleted file mode 100644 index 6cca906..0000000 --- a/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js +++ /dev/null @@ -1 +0,0 @@ -import{a as r}from"../chunks/D-gDZzN6.js";import{w as t}from"../chunks/DGcYlAAw.js";export{t as load_css,r as start}; diff --git a/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.br b/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.br deleted file mode 100644 index 8a9d8578d90762c564c2564763fc126427d25cad..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 108 zcmV-y0F(b4bpQw~4(x`{?~rj+byVkso>a1SPOHqYEXp$K`++FK--}4O?4&|jS_U~~ zrHvMwPR_3;<-0&HQY3 OpxIl60Vg<6l12xAdoINQ diff --git a/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.gz b/apps/dashboard/build/_app/immutable/entry/start.Bnkotnxp.js.gz deleted file mode 100644 index 70f2eaad12ee1ccdb779d62c8fae0e32c45a3ac0..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 107 zcmb2|=3oE;CgIa(bWiAOt@I1=&5?5vOTwL=`hK McrV+WR|d2L0JHEZ3IG5A literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js b/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js deleted file mode 100644 index 1753ddd..0000000 --- a/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js +++ /dev/null @@ -1,86 +0,0 @@ -import"../chunks/Bzak7iHL.js";import{o as Xe}from"../chunks/GG5zm9kr.js";import{f as ce,e as s,d as a,r as t,t as B,p as Ke,n as _e,g as e,a as He,s as ie,c as ht,h as k,u as G}from"../chunks/CpWkWWOo.js";import{s as h,d as Ge,a as J,e as Pe}from"../chunks/BlVfL1ME.js";import{i as q}from"../chunks/B4yTwGkE.js";import{e as Se,i as Fe}from"../chunks/CGEBXrjl.js";import{c as Ze,a as u,f as x,t as et}from"../chunks/CHOnp4oo.js";import{s as tt}from"../chunks/CJCPY1OL.js";import{s as ke,r as gt}from"../chunks/A7po6GxK.js";import{s as U}from"../chunks/aVbAZ-t7.js";import{b as bt}from"../chunks/sZcqyNBA.js";import{b as xt}from"../chunks/CJsMJEun.js";import{a as se,s as Ve}from"../chunks/C6HuKgyx.js";import{s as _t,g as at}from"../chunks/D-gDZzN6.js";import{b as he}from"../chunks/DGcYlAAw.js";import{s as lt,m as ot,a as dt,e as kt,w as st,u as yt,i as wt,f as $t}from"../chunks/MAY1QfFZ.js";import{i as At}from"../chunks/BUoSzNdg.js";import{s as ct}from"../chunks/Cx-f-Pzo.js";import{t as Te}from"../chunks/D4ymNiig.js";import{a as Oe}from"../chunks/554JRhq6.js";import{d as Ct,w as vt,g as pt}from"../chunks/BeMFXnHE.js";const Mt=()=>{const r=_t;return{page:{subscribe:r.page.subscribe},navigating:{subscribe:r.navigating.subscribe},updated:r.updated}},Et={subscribe(r){return Mt().page.subscribe(r)}};var Tt=x('
      ');function St(r){const i=()=>se(lt,"$suppressedCount",o),[o,n]=Ve();var g=Ze(),C=ce(g);{var y=N=>{var $=Tt(),w=s(a($),2),p=a(w);t(w),t($),B(()=>h(p,`Actively forgetting ${i()??""} ${i()===1?"memory":"memories"}`)),u(N,$)};q(C,N=>{i()>0&&N(y)})}u(r,g),n()}var jt=x(''),Dt=x('
      ');function It(r,i){Ke(i,!1);const o=()=>se(Te,"$toasts",n),[n,g]=Ve(),C={DreamCompleted:"✦",ConsolidationCompleted:"◉",ConnectionDiscovered:"⟷",MemoryPromoted:"↑",MemoryDemoted:"↓",MemorySuppressed:"◬",MemoryUnsuppressed:"◉",Rac1CascadeSwept:"✺",MemoryDeleted:"✕",HookVerdictRecorded:"⚑"};function y(p){return C[p]??"◆"}function N(p){Te.dismiss(p.id)}function $(p,d){(p.key==="Enter"||p.key===" ")&&(p.preventDefault(),Te.dismiss(d.id))}At();var w=Dt();Se(w,5,o,p=>p.id,(p,d)=>{var M=jt(),R=s(a(M),2),V=a(R),Y=a(V),ee=a(Y,!0);t(Y);var Q=s(Y,2),re=a(Q,!0);t(Q),t(V);var v=s(V,2),m=a(v,!0);t(v),t(R),_e(2),t(M),B(A=>{ke(M,"aria-label",`${e(d).title??""}: ${e(d).body??""}. Click to dismiss.`),ct(M,`--toast-color: ${e(d).color??""}; --toast-dwell: ${e(d).dwellMs??""}ms;`),h(ee,A),h(re,e(d).title),h(m,e(d).body)},[()=>y(e(d).type)]),J("click",M,()=>N(e(d))),J("keydown",M,A=>$(A,e(d))),Pe("mouseenter",M,()=>Te.pauseDwell(e(d).id,e(d).dwellMs)),Pe("mouseleave",M,()=>Te.resumeDwell(e(d).id)),Pe("focus",M,()=>Te.pauseDwell(e(d).id,e(d).dwellMs)),Pe("blur",M,()=>Te.resumeDwell(e(d).id)),u(p,M)}),t(w),u(r,w),He(),g()}Ge(["click","keydown"]);function Ne(r){const i=r.data;if(!i||typeof i!="object")return null;const o=i.timestamp??i.at??i.occurred_at;if(o==null)return null;if(typeof o=="number")return Number.isFinite(o)?o>1e12?o:o*1e3:null;if(typeof o!="string")return null;const n=Date.parse(o);return Number.isFinite(n)?n:null}const Qe=10,ut=3e4,Ft=Qe*ut;function Nt(r,i){const o=i-Ft,n=new Array(Qe).fill(0);for(const C of r){if(C.type==="Heartbeat")continue;const y=Ne(C);if(y===null||yi)continue;const N=Math.min(Qe-1,Math.floor((y-o)/ut));n[N]+=1}const g=Math.max(1,...n);return n.map(C=>({count:C,ratio:C/g}))}function Lt(r,i){const o=i-864e5;for(const n of r){if(n.type!=="DreamCompleted")continue;return(Ne(n)??i)>=o?n:null}return null}function Bt(r){if(!r||!r.data)return null;const i=r.data,o=typeof i.insights_generated=="number"?i.insights_generated:typeof i.insightsGenerated=="number"?i.insightsGenerated:null;return o!==null&&Number.isFinite(o)?o:null}function Rt(r,i){let o=null,n=null;for(const N of r)if(!o&&N.type==="DreamStarted"&&(o=N),!n&&N.type==="DreamCompleted"&&(n=N),o&&n)break;if(!o)return!1;const g=Ne(o)??i,C=i-300*1e3;return g=n}return!1}var Ot=x(' at risk',1),Kt=x('0 at risk',1),Ht=x('— at risk',1),Gt=x(' intentions',1),Wt=x('— intentions'),qt=x('· insights',1),zt=x('✦ Last dream: ',1),Yt=x('No recent dream'),Qt=x('
      '),Ut=x('
      DREAMING...
      ',1),Xt=x(''),Zt=x('
      memories · avg retention
      ');function Jt(r,i){Ke(i,!0);const o=()=>se(dt,"$avgRetention",C),n=()=>se(kt,"$eventFeed",C),g=()=>se(ot,"$memoryCount",C),[C,y]=Ve(),N=G(()=>Math.round((o()??0)*100)),$=G(()=>(o()??0)>=.5);let w=ie(null);async function p(){try{const l=await Oe.retentionDistribution();if(Array.isArray(l.endangered)&&l.endangered.length>0){k(w,l.endangered.length,!0);return}const c=l.distribution??[];let j=0;for(const _ of c){const D=/^(\d+)/.exec(_.range);if(!D)continue;const F=Number.parseInt(D[1],10);Number.isFinite(F)&&F<30&&(j+=_.count??0)}k(w,j,!0)}catch{k(w,null)}}let d=ie(null);async function M(){var l;try{const c=await Oe.intentions("active");k(d,c.total??((l=c.intentions)==null?void 0:l.length)??0,!0)}catch{k(d,null)}}let R=ie(ht(Date.now()));const V=G(()=>{const l=n(),c=Lt(l,e(R)),j=c?Ne(c)??e(R):null,_=j!==null?e(R)-j:null;return{isDreaming:Rt(l,e(R)),recent:c,recentMsAgo:_,insights:Bt(c)}}),Y=G(()=>Nt(n(),e(R))),ee=G(()=>Pt(n(),e(R)));Xe(()=>{p(),M();const l=setInterval(()=>{k(R,Date.now(),!0)},1e3),c=setInterval(()=>{p(),M()},6e4);return()=>{clearInterval(l),clearInterval(c)}});var Q=Zt();let re;var v=a(Q),m=a(v),A=a(m);let ye;var Ae=s(A,2);let je;t(m);var ve=s(m,2),T=a(ve,!0);t(ve);var E=s(ve,6);let b;var X=a(E);t(E),_e(2),t(v);var W=s(v,4),K=a(W);{var le=l=>{var c=Ot(),j=ce(c),_=a(j,!0);t(j),_e(2),B(()=>h(_,e(w))),u(l,c)},S=l=>{var c=Kt();_e(2),u(l,c)},I=l=>{var c=Ht();_e(2),u(l,c)};q(K,l=>{e(w)!==null&&e(w)>0?l(le):e(w)===0?l(S,1):l(I,!1)})}t(W);var f=s(W,4),O=a(f);{var z=l=>{var c=Gt(),j=ce(c);let _;var D=s(j,2);let F;var H=a(D,!0);t(D),_e(2),B(()=>{_=U(j,1,"inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,_,{"bg-node-pattern":e(d)>5,"animate-ping-slow":e(d)>5,"bg-muted":e(d)<=5}),F=U(D,1,"tabular-nums svelte-1kk3799",null,F,{"text-node-pattern":e(d)>5,"text-text":e(d)>0&&e(d)<=5,"text-muted":e(d)===0}),h(H,e(d))}),u(l,c)},pe=l=>{var c=Wt();u(l,c)};q(O,l=>{e(d)!==null?l(z):l(pe,!1)})}t(f);var te=s(f,4),oe=a(te);{var ue=l=>{var c=zt(),j=s(ce(c),4),_=a(j,!0);t(j);var D=s(j,2);{var F=H=>{var ne=qt(),Me=s(ce(ne),2),we=a(Me,!0);t(Me),_e(2),B(()=>h(we,e(V).insights)),u(H,ne)};q(D,H=>{e(V).insights!==null&&H(F)})}B(H=>h(_,H),[()=>Vt(e(V).recentMsAgo)]),u(l,c)},ae=l=>{var c=Yt();u(l,c)};q(oe,l=>{e(V).recent&&e(V).recentMsAgo!==null?l(ue):l(ae,!1)})}t(te);var de=s(te,4),me=s(a(de),2);Se(me,21,()=>e(Y),Fe,(l,c)=>{var j=Qt();B(_=>ct(j,`height: ${_??""}%; opacity: ${e(c).count===0?.18:.5+e(c).ratio*.5};`),[()=>Math.max(10,e(c).ratio*100)]),u(l,j)}),t(me),t(de);var Ce=s(de,2);{var Be=l=>{var c=Ut();_e(2),u(l,c)};q(Ce,l=>{e(V).isDreaming&&l(Be)})}var De=s(Ce,4);{var Re=l=>{var c=Xt();u(l,c)};q(De,l=>{e(ee)&&l(Re)})}t(Q),B(()=>{re=U(Q,1,"ambient-strip relative flex h-9 w-full items-center gap-0 overflow-hidden border-b border-synapse/15 bg-black/40 px-3 text-[11px] text-dim backdrop-blur-md svelte-1kk3799",null,re,{"ambient-flash":e(ee)}),ye=U(A,1,"absolute inline-flex h-full w-full animate-ping rounded-full opacity-75 svelte-1kk3799",null,ye,{"bg-recall":e($),"bg-warning":!e($)}),je=U(Ae,1,"relative inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,je,{"bg-recall":e($),"bg-warning":!e($)}),h(T,g()),b=U(E,1,"svelte-1kk3799",null,b,{"text-recall":e($),"text-warning":!e($)}),h(X,`${e(N)??""}%`)}),u(r,Q),He(),y()}var ea=x(" "),ta=x('
      • '),aa=x(' ',1),sa=x('

      Appeal recorded.

      '),ra=x('

      No appealable veto in this receipt.

      '),na=x('
      Claim

      Verdict

      Precedent
        Fix

        Appeal
        '),ia=x('
        ');function la(r,i){Ke(i,!0);const o=["PASS","NOTE","CAUTION","VETO","APPEALED"];let n=ie(null),g=ie(""),C=ie(!1),y=ie(null),N=ie(null),$=G(()=>{var v;return((v=e(n))==null?void 0:v.verdictBar)??(e(g)?"CAUTION":"NOTE")}),w=G(()=>{var v,m;return((v=e(n))==null?void 0:v.claims.find(A=>A.decision==="veto"))??((m=e(n))==null?void 0:m.claims.find(A=>A.decision==="appealed"))??null}),p=G(()=>{var v;return e(w)??((v=e(n))==null?void 0:v.claims[0])??null}),d=G(()=>!!e(n)||!!e(g));Xe(()=>{M();const v=window.setInterval(M,4e3);return()=>window.clearInterval(v)});async function M(){var v;try{const m=await Oe.sanhedrin.latest();k(n,m.receipt,!0),k(g,""),((v=m.receipt)==null?void 0:v.verdictBar)==="VETO"&&m.receipt.id!==e(N)&&(k(C,!0),k(N,m.receipt.id,!0))}catch(m){k(g,m instanceof Error?m.message:String(m),!0)}}async function R(v){var m;if(!(!e(w)||((m=e(n))==null?void 0:m.verdictBar)!=="VETO")){k(y,v,!0);try{const A=await Oe.sanhedrin.appeal(v,void 0,e(w).id,e(n).id);k(n,A.receipt,!0),k(C,!0),k(g,"")}catch(A){k(g,A instanceof Error?A.message:String(A),!0)}finally{k(y,null)}}}function V(v){if(!v)return"";const m=new Date(v);return Number.isNaN(m.getTime())?"":m.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"})}function Y(v){var m;return(m=v==null?void 0:v.precedent)!=null&&m.length?v.precedent.map(A=>A.summary??A.command??"Precedent recorded.").slice(0,3):["No precedent attached."]}var ee=Ze(),Q=ce(ee);{var re=v=>{var m=ia(),A=a(m),ye=s(a(A),2);Se(ye,21,()=>o,Fe,(S,I)=>{var f=ea();let O;var z=a(f,!0);t(f),B(()=>{ke(f,"aria-current",e(I)===e($)?"true":void 0),O=U(f,1,"svelte-1j425e6",null,O,{active:e(I)===e($)}),h(z,e(I))}),u(S,f)}),t(ye);var Ae=s(ye,2),je=a(Ae);t(Ae);var ve=s(Ae,2),T=a(ve);{var E=S=>{var I=et();B(()=>h(I,e(g))),u(S,I)},b=S=>{var I=et();B(()=>h(I,e(n).summary)),u(S,I)};q(T,S=>{e(g)?S(E):e(n)&&S(b,1)})}t(ve);var X=s(ve,2),W=a(X,!0);t(X),t(A);var K=s(A,2);{var le=S=>{var I=na(),f=a(I),O=a(f),z=s(a(O),2),pe=a(z,!0);t(z),t(O);var te=s(O,2),oe=s(a(te),2),ue=a(oe);t(oe),t(te);var ae=s(te,2),de=s(a(ae),2);Se(de,21,()=>Y(e(p)),Fe,(_,D)=>{var F=ta(),H=a(F,!0);t(F),B(()=>h(H,e(D))),u(_,F)}),t(de),t(ae);var me=s(ae,2),Ce=s(a(me),2),Be=a(Ce,!0);t(Ce),t(me),t(f);var De=s(f,2),Re=s(a(De),2);{var l=_=>{var D=aa(),F=ce(D),H=a(F,!0);t(F);var ne=s(F,2),Me=a(ne,!0);t(ne);var we=s(ne,2),We=a(we,!0);t(we),B((L,P,fe)=>{F.disabled=L,h(H,e(y)==="stale"?"Saving":"Stale"),ne.disabled=P,h(Me,e(y)==="wrong"?"Saving":"Wrong"),we.disabled=fe,h(We,e(y)==="too_strict"?"Saving":"Too strict")},[()=>!!e(y),()=>!!e(y),()=>!!e(y)]),J("click",F,()=>R("stale")),J("click",ne,()=>R("wrong")),J("click",we,()=>R("too_strict")),u(_,D)},c=_=>{var D=sa();u(_,D)},j=_=>{var D=ra();u(_,D)};q(Re,_=>{e(w)&&e(n).verdictBar==="VETO"?_(l):e(n).verdictBar==="APPEALED"?_(c,1):_(j,!1)})}t(De),t(I),B(()=>{var _,D,F,H;h(pe,((_=e(p))==null?void 0:_.text)??e(n).draftPreview),h(ue,`${((D=e(p))==null?void 0:D.decision)??e(n).overall??""} · ${((F=e(p))==null?void 0:F.evidence_state)??e($)??""}`),h(Be,((H=e(p))==null?void 0:H.fix)||"No change required.")}),u(S,I)};q(K,S=>{e(C)&&e(n)&&S(le)})}t(m),B((S,I)=>{U(m,1,S,"svelte-1j425e6"),ke(A,"aria-expanded",e(C)),h(je,`Current verdict: ${e($)??""}`),h(W,I)},[()=>`verdict-bar tone-${e($).toLowerCase()}`,()=>{var S;return V((S=e(n))==null?void 0:S.createdAt)}]),J("click",A,()=>k(C,!e(C))),u(v,m)};q(Q,v=>{e(d)&&v(re)})}u(r,ee),He()}Ge(["click"]);const mt="vestige.theme",rt="vestige-theme-light",Le=vt("dark"),Ue=vt(!0),nt=Ct([Le,Ue],([r,i])=>r==="auto"?i?"dark":"light":r);function oa(r){return r==="dark"||r==="light"||r==="auto"}function da(r){if(oa(r)){Le.set(r);try{localStorage.setItem(mt,r)}catch{}}}function Ye(){const r=pt(Le);da(r==="dark"?"light":r==="light"?"auto":"dark")}function ca(){if(document.getElementById(rt))return;const r=document.createElement("style");r.id=rt,r.textContent=` -/* Vestige light-mode overrides — injected by theme.ts. - * Activated by [data-theme='light'] on . - * Tokens mirror the real names used in app.css so the cascade stays clean. */ -[data-theme='light'] { - /* Core surface palette (slate scale) */ - --color-void: #f8fafc; /* slate-50 — page background */ - --color-abyss: #f1f5f9; /* slate-100 */ - --color-deep: #e2e8f0; /* slate-200 */ - --color-surface: #f1f5f9; /* slate-100 */ - --color-elevated: #e2e8f0; /* slate-200 */ - --color-subtle: #cbd5e1; /* slate-300 */ - --color-muted: #94a3b8; /* slate-400 */ - --color-dim: #475569; /* slate-600 */ - --color-text: #0f172a; /* slate-900 */ - --color-bright: #020617; /* slate-950 */ -} - -/* Baseline body/html wiring — app.css sets these against the dark - * tokens; we just let the variables do the work. Reassert for clarity. */ -[data-theme='light'] html, -html[data-theme='light'] { - background: var(--color-void); - color: var(--color-text); -} - -/* Glass surfaces — recompose on a light canvas. The original alphas - * are tuned for dark; invert-and-tint for light so panels still read - * as elevated instead of vanishing. */ -[data-theme='light'] .glass { - background: rgba(255, 255, 255, 0.65); - border: 1px solid rgba(99, 102, 241, 0.12); - box-shadow: - inset 0 1px 0 0 rgba(255, 255, 255, 0.6), - 0 4px 24px rgba(15, 23, 42, 0.08); -} -[data-theme='light'] .glass-subtle { - background: rgba(255, 255, 255, 0.55); - border: 1px solid rgba(99, 102, 241, 0.1); - box-shadow: - inset 0 1px 0 0 rgba(255, 255, 255, 0.5), - 0 2px 12px rgba(15, 23, 42, 0.06); -} -[data-theme='light'] .glass-sidebar { - background: rgba(248, 250, 252, 0.82); - border-right: 1px solid rgba(99, 102, 241, 0.14); - box-shadow: - inset -1px 0 0 0 rgba(255, 255, 255, 0.4), - 4px 0 24px rgba(15, 23, 42, 0.08); -} -[data-theme='light'] .glass-panel { - background: rgba(255, 255, 255, 0.75); - border: 1px solid rgba(99, 102, 241, 0.14); - box-shadow: - inset 0 1px 0 0 rgba(255, 255, 255, 0.5), - 0 8px 32px rgba(15, 23, 42, 0.1); -} - -/* Halve glow intensity — neon accents stay recognizable without - * washing out on slate-50. */ -[data-theme='light'] .glow-synapse { - box-shadow: 0 0 10px rgba(99, 102, 241, 0.15), 0 0 30px rgba(99, 102, 241, 0.05); -} -[data-theme='light'] .glow-dream { - box-shadow: 0 0 10px rgba(168, 85, 247, 0.15), 0 0 30px rgba(168, 85, 247, 0.05); -} -[data-theme='light'] .glow-memory { - box-shadow: 0 0 10px rgba(59, 130, 246, 0.15), 0 0 30px rgba(59, 130, 246, 0.05); -} - -/* Ambient orbs are gorgeous on black and blinding on white. Tame them. */ -[data-theme='light'] .ambient-orb { - opacity: 0.18; - filter: blur(100px); -} - -/* Scrollbar recolor for the lighter surface. */ -[data-theme='light'] ::-webkit-scrollbar-thumb { - background: #cbd5e1; -} -[data-theme='light'] ::-webkit-scrollbar-thumb:hover { - background: #94a3b8; -} -`,document.head.appendChild(r)}function it(r){document.documentElement.dataset.theme=r}let ge=null,$e=null,be=null,xe=null;function va(){ge&&$e&&ge.removeEventListener("change",$e),xe==null||xe(),be==null||be(),ge=null,$e=null,xe=null,be=null,ca();let r="dark";try{const i=localStorage.getItem(mt);(i==="dark"||i==="light"||i==="auto")&&(r=i)}catch{}return Le.set(r),ge=window.matchMedia("(prefers-color-scheme: dark)"),Ue.set(ge.matches),$e=i=>Ue.set(i.matches),ge.addEventListener("change",$e),it(pt(nt)),xe=nt.subscribe(it),be=Le.subscribe(()=>{}),()=>{ge&&$e&&ge.removeEventListener("change",$e),ge=null,$e=null,xe==null||xe(),be==null||be(),xe=null,be=null}}var pa=x('');function ua(r){const i=()=>se(Le,"$theme",o),[o,n]=Ve(),g={dark:"Dark",light:"Light",auto:"Auto (system)"},C={dark:"light",light:"auto",auto:"dark"};let y=G(i),N=G(()=>C[e(y)]),$=G(()=>`Toggle theme: ${g[e(y)]} (click for ${g[e(N)]})`);var w=pa(),p=a(w),d=a(p);let M;var R=s(d,2);let V;var Y=s(R,2);let ee;t(p),t(w),B(()=>{ke(w,"aria-label",e($)),ke(w,"title",e($)),ke(w,"data-mode",e(y)),M=U(d,0,"icon svelte-1cmi4dh",null,M,{active:e(y)==="dark"}),V=U(R,0,"icon svelte-1cmi4dh",null,V,{active:e(y)==="light"}),ee=U(Y,0,"icon svelte-1cmi4dh",null,ee,{active:e(y)==="auto"})}),J("click",w,function(...Q){Ye==null||Ye.apply(this,Q)}),u(r,w),n()}Ge(["click"]);var ma=x('         '),fa=x('
        '),ha=x(''),ga=x('         '),ba=x('
        ',1),xa=x(''),_a=x('
        No matches
        '),ka=x('
        ◎ esc
        '),ya=x(" ",1);function Ga(r,i){Ke(i,!0);const o=()=>se(Et,"$page",$),n=()=>se(wt,"$isConnected",$),g=()=>se(ot,"$memoryCount",$),C=()=>se(dt,"$avgRetention",$),y=()=>se(yt,"$uptimeSeconds",$),N=()=>se(lt,"$suppressedCount",$),[$,w]=Ve();let p=ie(!1),d=ie(""),M=ie(void 0),R=G(()=>o().url.pathname.startsWith(he)?o().url.pathname.slice(he.length)||"/":o().url.pathname),V=G(()=>e(R)==="/waitlist"||e(R).startsWith("/waitlist/"));Xe(()=>{e(V)||st.connect();const T=va();function E(b){if(e(V))return;if((b.metaKey||b.ctrlKey)&&b.key==="k"){b.preventDefault(),k(p,!e(p)),k(d,""),e(p)&&requestAnimationFrame(()=>{var K;return(K=e(M))==null?void 0:K.focus()});return}if(b.key==="Escape"&&e(p)){k(p,!1);return}if(b.target instanceof HTMLInputElement||b.target instanceof HTMLTextAreaElement)return;if(b.key==="/"){b.preventDefault();const K=document.querySelector('input[type="text"]');K==null||K.focus();return}const W={g:"/graph",m:"/memories",t:"/timeline",f:"/feed",e:"/explore",i:"/intentions",s:"/stats",r:"/reasoning",a:"/activation",d:"/dreams",c:"/schedule",p:"/importance",u:"/duplicates",x:"/contradictions",n:"/patterns"}[b.key.toLowerCase()];W&&!b.metaKey&&!b.ctrlKey&&!b.altKey&&(b.preventDefault(),at(`${he}${W}`))}return window.addEventListener("keydown",E),()=>{st.disconnect(),window.removeEventListener("keydown",E),T()}});const Y=[{href:"/graph",label:"Graph",icon:"◎",shortcut:"G"},{href:"/reasoning",label:"Reasoning",icon:"✦",shortcut:"R"},{href:"/memories",label:"Memories",icon:"◈",shortcut:"M"},{href:"/timeline",label:"Timeline",icon:"◷",shortcut:"T"},{href:"/feed",label:"Feed",icon:"◉",shortcut:"F"},{href:"/explore",label:"Explore",icon:"◬",shortcut:"E"},{href:"/activation",label:"Activation",icon:"◈",shortcut:"A"},{href:"/dreams",label:"Dreams",icon:"✧",shortcut:"D"},{href:"/schedule",label:"Schedule",icon:"◷",shortcut:"C"},{href:"/importance",label:"Importance",icon:"◎",shortcut:"P"},{href:"/duplicates",label:"Duplicates",icon:"◉",shortcut:"U"},{href:"/contradictions",label:"Contradictions",icon:"⚠",shortcut:"X"},{href:"/patterns",label:"Patterns",icon:"▦",shortcut:"N"},{href:"/intentions",label:"Intentions",icon:"◇",shortcut:"I"},{href:"/stats",label:"Stats",icon:"◫",shortcut:"S"},{href:"/settings",label:"Settings",icon:"⚙",shortcut:","}],ee=Y.slice(0,5);function Q(T,E){const b=E.startsWith(he)?E.slice(he.length)||"/":E;return T==="/graph"?b==="/"||b==="/graph":b.startsWith(T)}let re=G(()=>e(d)?Y.filter(T=>T.label.toLowerCase().includes(e(d).toLowerCase())):Y);function v(T){k(p,!1),k(d,""),at(`${he}${T}`)}var m=ya(),A=ce(m);{var ye=T=>{var E=Ze(),b=ce(E);tt(b,()=>i.children),u(T,E)},Ae=T=>{var E=ba(),b=s(ce(E),6),X=a(b),W=a(X),K=s(W,2);Se(K,21,()=>Y,Fe,(L,P)=>{const fe=G(()=>Q(e(P).href,o().url.pathname));var Z=ma(),Ee=a(Z),qe=a(Ee,!0);t(Ee);var Ie=s(Ee,2),ze=a(Ie,!0);t(Ie);var Je=s(Ie,2),ft=a(Je,!0);t(Je),t(Z),B(()=>{ke(Z,"href",`${he??""}${e(P).href??""}`),U(Z,1,`flex items-center gap-3 px-3 py-2.5 rounded-lg transition-all duration-200 text-sm - ${e(fe)?"bg-synapse/15 text-synapse-glow border border-synapse/30 shadow-[0_0_12px_rgba(99,102,241,0.15)] nav-active-border":"text-dim hover:text-text hover:bg-white/[0.03] border border-transparent"}`),h(qe,e(P).icon),h(ze,e(P).label),h(ft,e(P).shortcut)}),u(L,Z)}),t(K);var le=s(K,2),S=a(le);t(le);var I=s(le,2),f=a(I),O=a(f),z=s(O,2),pe=a(z,!0);t(z);var te=s(z,2),oe=a(te);ua(oe),t(te),t(f);var ue=s(f,2),ae=a(ue),de=a(ae);t(ae);var me=s(ae,2),Ce=a(me);t(me);var Be=s(me,2);{var De=L=>{var P=fa(),fe=a(P);t(P),B(Z=>h(fe,`up ${Z??""}`),[()=>$t(y())]),u(L,P)};q(Be,L=>{y()>0&&L(De)})}t(ue);var Re=s(ue,2);{var l=L=>{var P=ha(),fe=a(P);St(fe),t(P),u(L,P)};q(Re,L=>{N()>0&&L(l)})}t(I),t(X);var c=s(X,2),j=a(c);Jt(j,{});var _=s(j,2);la(_,{});var D=s(_,2),F=a(D);tt(F,()=>i.children),t(D),t(c);var H=s(c,2),ne=a(H),Me=a(ne);Se(Me,17,()=>ee,Fe,(L,P)=>{const fe=G(()=>Q(e(P).href,o().url.pathname));var Z=ga(),Ee=a(Z),qe=a(Ee,!0);t(Ee);var Ie=s(Ee,2),ze=a(Ie,!0);t(Ie),t(Z),B(()=>{ke(Z,"href",`${he??""}${e(P).href??""}`),U(Z,1,`flex flex-col items-center gap-0.5 px-3 py-2 rounded-lg transition-all min-w-[3.5rem] - ${e(fe)?"text-synapse-glow":"text-muted"}`),h(qe,e(P).icon),h(ze,e(P).label)}),u(L,Z)});var we=s(Me,2);t(ne),t(H),t(b);var We=s(b,2);It(We,{}),B(L=>{ke(W,"href",`${he??""}/graph`),U(O,1,`w-2 h-2 rounded-full ${n()?"bg-recall animate-pulse-glow":"bg-decay"}`),h(pe,n()?"Connected":"Offline"),h(de,`${g()??""} memories`),h(Ce,`${L??""}% retention`)},[()=>(C()*100).toFixed(0)]),J("click",S,()=>{k(p,!0),k(d,""),requestAnimationFrame(()=>{var L;return(L=e(M))==null?void 0:L.focus()})}),J("click",we,()=>{k(p,!0),k(d,""),requestAnimationFrame(()=>{var L;return(L=e(M))==null?void 0:L.focus()})}),u(T,E)};q(A,T=>{e(V)?T(ye):T(Ae,!1)})}var je=s(A,2);{var ve=T=>{var E=ka(),b=a(E),X=a(b),W=s(a(X),2);gt(W),xt(W,f=>k(M,f),()=>e(M)),_e(2),t(X);var K=s(X,2),le=a(K);Se(le,17,()=>e(re),Fe,(f,O)=>{var z=xa(),pe=a(z),te=a(pe,!0);t(pe);var oe=s(pe,2),ue=a(oe,!0);t(oe);var ae=s(oe,2),de=a(ae,!0);t(ae),t(z),B(()=>{h(te,e(O).icon),h(ue,e(O).label),h(de,e(O).shortcut)}),J("click",z,()=>v(e(O).href)),u(f,z)});var S=s(le,2);{var I=f=>{var O=_a();u(f,O)};q(S,f=>{e(re).length===0&&f(I)})}t(K),t(b),t(E),J("keydown",E,f=>{f.key==="Escape"&&k(p,!1)}),J("click",E,f=>{f.target===f.currentTarget&&k(p,!1)}),J("keydown",W,f=>{f.key==="Enter"&&e(re).length>0&&v(e(re)[0].href)}),bt(W,()=>e(d),f=>k(d,f)),u(T,E)};q(je,T=>{e(p)&&!e(V)&&T(ve)})}u(r,m),He(),w()}Ge(["click","keydown"]);export{Ga as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.br b/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.br deleted file mode 100644 index 91dae85c22fe054d71781ce4958e9107cebe375a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9644 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 diff --git a/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.gz b/apps/dashboard/build/_app/immutable/nodes/0.BSxKGxRx.js.gz deleted file mode 100644 index 524ab3b4cbb4f45c412a3343451d28da4008fd0b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 10974 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 M0c3Y|UYmLV0MEgV&;S4c diff --git a/apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js b/apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js new file mode 100644 index 0000000..c8a2beb --- /dev/null +++ b/apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js @@ -0,0 +1,86 @@ +import"../chunks/Bzak7iHL.js";import{o as Xe}from"../chunks/GG5zm9kr.js";import{f as le,e as s,d as a,r as t,t as I,p as We,n as fe,g as e,a as qe,s as ne,c as ht,h,u as q}from"../chunks/CpWkWWOo.js";import{s as m,d as ze,a as re,e as Ge}from"../chunks/BlVfL1ME.js";import{i as G}from"../chunks/B4yTwGkE.js";import{e as Ie,i as Ve}from"../chunks/CGEBXrjl.js";import{c as Ze,a as v,f as g,t as et}from"../chunks/CHOnp4oo.js";import{s as tt}from"../chunks/CJCPY1OL.js";import{s as we,r as gt}from"../chunks/A7po6GxK.js";import{s as te}from"../chunks/aVbAZ-t7.js";import{b as bt}from"../chunks/sZcqyNBA.js";import{b as xt}from"../chunks/CJsMJEun.js";import{a as oe,s as He}from"../chunks/C6HuKgyx.js";import{s as kt,g as at}from"../chunks/C2TQQEIa.js";import{b as xe}from"../chunks/D8UfWY0j.js";import{s as lt,m as ot,a as dt,e as _t,w as st,u as yt,i as wt,f as $t}from"../chunks/MAY1QfFZ.js";import{i as At}from"../chunks/BUoSzNdg.js";import{s as ct}from"../chunks/Cx-f-Pzo.js";import{t as De}from"../chunks/D4ymNiig.js";import{a as Ke}from"../chunks/B7CfdQuM.js";import{d as Ct,w as vt,g as pt}from"../chunks/BeMFXnHE.js";const Mt=()=>{const n=kt;return{page:{subscribe:n.page.subscribe},navigating:{subscribe:n.navigating.subscribe},updated:n.updated}},Tt={subscribe(n){return Mt().page.subscribe(n)}};var Et=g('
        ');function St(n){const l=()=>oe(lt,"$suppressedCount",o),[o,i]=He();var x=Ze(),T=le(x);{var y=N=>{var C=Et(),$=s(a(C),2),p=a($);t($),t(C),I(()=>m(p,`Actively forgetting ${l()??""} ${l()===1?"memory":"memories"}`)),v(N,C)};G(T,N=>{l()>0&&N(y)})}v(n,x),i()}var jt=g(''),Dt=g('
        ');function It(n,l){We(l,!1);const o=()=>oe(De,"$toasts",i),[i,x]=He(),T={DreamCompleted:"✦",ConsolidationCompleted:"◉",ConnectionDiscovered:"⟷",MemoryPromoted:"↑",MemoryDemoted:"↓",MemorySuppressed:"◬",MemoryUnsuppressed:"◉",Rac1CascadeSwept:"✺",MemoryDeleted:"✕",HookVerdictRecorded:"⚑"};function y(p){return T[p]??"◆"}function N(p){De.dismiss(p.id)}function C(p,c){(p.key==="Enter"||p.key===" ")&&(p.preventDefault(),De.dismiss(c.id))}At();var $=Dt();Ie($,5,o,p=>p.id,(p,c)=>{var E=jt(),L=s(a(E),2),V=a(L),Z=a(V),z=a(Z,!0);t(Z);var ae=s(Z,2),de=a(ae,!0);t(ae),t(V);var u=s(V,2),f=a(u,!0);t(u),t(L),fe(2),t(E),I(M=>{we(E,"aria-label",`${e(c).title??""}: ${e(c).body??""}. Click to dismiss.`),ct(E,`--toast-color: ${e(c).color??""}; --toast-dwell: ${e(c).dwellMs??""}ms;`),m(z,M),m(de,e(c).title),m(f,e(c).body)},[()=>y(e(c).type)]),re("click",E,()=>N(e(c))),re("keydown",E,M=>C(M,e(c))),Ge("mouseenter",E,()=>De.pauseDwell(e(c).id,e(c).dwellMs)),Ge("mouseleave",E,()=>De.resumeDwell(e(c).id)),Ge("focus",E,()=>De.pauseDwell(e(c).id,e(c).dwellMs)),Ge("blur",E,()=>De.resumeDwell(e(c).id)),v(p,E)}),t($),v(n,$),qe(),x()}ze(["click","keydown"]);function Be(n){const l=n.data;if(!l||typeof l!="object")return null;const o=l.timestamp??l.at??l.occurred_at;if(o==null)return null;if(typeof o=="number")return Number.isFinite(o)?o>1e12?o:o*1e3:null;if(typeof o!="string")return null;const i=Date.parse(o);return Number.isFinite(i)?i:null}const Qe=10,ut=3e4,Ft=Qe*ut;function Nt(n,l){const o=l-Ft,i=new Array(Qe).fill(0);for(const T of n){if(T.type==="Heartbeat")continue;const y=Be(T);if(y===null||yl)continue;const N=Math.min(Qe-1,Math.floor((y-o)/ut));i[N]+=1}const x=Math.max(1,...i);return i.map(T=>({count:T,ratio:T/x}))}function Lt(n,l){const o=l-864e5;for(const i of n){if(i.type!=="DreamCompleted")continue;return(Be(i)??l)>=o?i:null}return null}function Vt(n){if(!n||!n.data)return null;const l=n.data,o=typeof l.insights_generated=="number"?l.insights_generated:typeof l.insightsGenerated=="number"?l.insightsGenerated:null;return o!==null&&Number.isFinite(o)?o:null}function Bt(n,l){let o=null,i=null;for(const N of n)if(!o&&N.type==="DreamStarted"&&(o=N),!i&&N.type==="DreamCompleted"&&(i=N),o&&i)break;if(!o)return!1;const x=Be(o)??l,T=l-300*1e3;return x=i}return!1}var Pt=g(' at risk',1),Kt=g('0 at risk',1),Ht=g('— at risk',1),Gt=g(' intentions',1),Wt=g('— intentions'),qt=g('· insights',1),zt=g('✦ Last dream: ',1),Yt=g('No recent dream'),Qt=g('
        '),Ut=g('telemetry unavailable'),Xt=g('· fail-open',1),Zt=g(' vetoes · appeals ',1),Jt=g('
        DREAMING...
        ',1),ea=g(''),ta=g('
        memories · avg retention
        ');function aa(n,l){We(l,!0);const o=()=>oe(dt,"$avgRetention",T),i=()=>oe(_t,"$eventFeed",T),x=()=>oe(ot,"$memoryCount",T),[T,y]=He(),N=q(()=>Math.round((o()??0)*100)),C=q(()=>(o()??0)>=.5);let $=ne(null);async function p(){try{const r=await Ke.retentionDistribution();if(Array.isArray(r.endangered)&&r.endangered.length>0){h($,r.endangered.length,!0);return}const d=r.distribution??[];let A=0;for(const R of d){const b=/^(\d+)/.exec(R.range);if(!b)continue;const w=Number.parseInt(b[1],10);Number.isFinite(w)&&w<30&&(A+=R.count??0)}h($,A,!0)}catch{h($,null)}}let c=ne(null);async function E(){var r;try{const d=await Ke.intentions("active");h(c,d.total??((r=d.intentions)==null?void 0:r.length)??0,!0)}catch{h(c,null)}}let L=ne(ht(Date.now()));const V=q(()=>{const r=i(),d=Lt(r,e(L)),A=d?Be(d)??e(L):null,R=A!==null?e(L)-A:null;return{isDreaming:Bt(r,e(L)),recent:d,recentMsAgo:R,insights:Vt(d)}}),Z=q(()=>Nt(i(),e(L)));let z=ne(null),ae=ne(!1);async function de(){try{h(z,await Ke.sanhedrin.telemetry(7),!0),h(ae,!1)}catch{h(z,null),h(ae,!0)}}const u=q(()=>Ot(i(),e(L)));Xe(()=>{p(),E(),de();const r=setInterval(()=>{h(L,Date.now(),!0)},1e3),d=setInterval(()=>{p(),E(),de()},6e4);return()=>{clearInterval(r),clearInterval(d)}});var f=ta();let M;var he=a(f),ge=a(he),Fe=a(ge);let $e;var j=s(Fe,2);let D;t(ge);var k=s(ge,2),se=a(k,!0);t(k);var Y=s(k,6);let P;var pe=a(Y);t(Y),fe(2),t(he);var S=s(he,4),F=a(S);{var _=r=>{var d=Pt(),A=le(d),R=a(A,!0);t(A),fe(2),I(()=>m(R,e($))),v(r,d)},K=r=>{var d=Kt();fe(2),v(r,d)},X=r=>{var d=Ht();fe(2),v(r,d)};G(F,r=>{e($)!==null&&e($)>0?r(_):e($)===0?r(K,1):r(X,!1)})}t(S);var ce=s(S,4),ue=a(ce);{var me=r=>{var d=Gt(),A=le(d);let R;var b=s(A,2);let w;var O=a(b,!0);t(b),fe(2),I(()=>{R=te(A,1,"inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,R,{"bg-node-pattern":e(c)>5,"animate-ping-slow":e(c)>5,"bg-muted":e(c)<=5}),w=te(b,1,"tabular-nums svelte-1kk3799",null,w,{"text-node-pattern":e(c)>5,"text-text":e(c)>0&&e(c)<=5,"text-muted":e(c)===0}),m(O,e(c))}),v(r,d)},be=r=>{var d=Wt();v(r,d)};G(ue,r=>{e(c)!==null?r(me):r(be,!1)})}t(ce);var J=s(ce,4),Ae=a(J);{var Ce=r=>{var d=zt(),A=s(le(d),4),R=a(A,!0);t(A);var b=s(A,2);{var w=O=>{var H=qt(),W=s(le(H),2),ee=a(W,!0);t(W),fe(2),I(()=>m(ee,e(V).insights)),v(O,H)};G(b,O=>{e(V).insights!==null&&O(w)})}I(O=>m(R,O),[()=>Rt(e(V).recentMsAgo)]),v(r,d)},Ne=r=>{var d=Yt();v(r,d)};G(Ae,r=>{e(V).recent&&e(V).recentMsAgo!==null?r(Ce):r(Ne,!1)})}t(J);var Te=s(J,4),Ee=s(a(Te),2);Ie(Ee,21,()=>e(Z),Ve,(r,d)=>{var A=Qt();I(R=>ct(A,`height: ${R??""}%; opacity: ${e(d).count===0?.18:.5+e(d).ratio*.5};`),[()=>Math.max(10,e(d).ratio*100)]),v(r,A)}),t(Ee),t(Te);var Se=s(Te,4),Oe=s(a(Se),2);{var je=r=>{var d=Ut();v(r,d)},Le=r=>{var d=Zt(),A=le(d),R=a(A,!0);t(A);var b=s(A,6),w=a(b,!0);t(b);var O=s(b,4);{var H=W=>{var ee=Xt(),ie=s(le(ee),2),Pe=a(ie,!0);t(ie),fe(2),I(()=>m(Pe,e(z).failOpen)),v(W,ee)};G(O,W=>{var ee;(ee=e(z))!=null&&ee.failOpen&&W(H)})}I(()=>{var W,ee,ie;m(R,((ee=(W=e(z))==null?void 0:W.byVerdict)==null?void 0:ee.VETO)??"—"),m(w,((ie=e(z))==null?void 0:ie.appeals)??"—")}),v(r,d)};G(Oe,r=>{e(ae)?r(je):r(Le,!1)})}t(Se);var B=s(Se,2);{var Q=r=>{var d=Jt();fe(2),v(r,d)};G(B,r=>{e(V).isDreaming&&r(Q)})}var U=s(B,4);{var ve=r=>{var d=ea();v(r,d)};G(U,r=>{e(u)&&r(ve)})}t(f),I(()=>{M=te(f,1,"ambient-strip relative flex h-9 w-full items-center gap-0 overflow-hidden border-b border-synapse/15 bg-black/40 px-3 text-[11px] text-dim backdrop-blur-md svelte-1kk3799",null,M,{"ambient-flash":e(u)}),$e=te(Fe,1,"absolute inline-flex h-full w-full animate-ping rounded-full opacity-75 svelte-1kk3799",null,$e,{"bg-recall":e(C),"bg-warning":!e(C)}),D=te(j,1,"relative inline-flex h-2 w-2 rounded-full svelte-1kk3799",null,D,{"bg-recall":e(C),"bg-warning":!e(C)}),m(se,x()),P=te(Y,1,"svelte-1kk3799",null,P,{"text-recall":e(C),"text-warning":!e(C)}),m(pe,`${e(N)??""}%`)}),v(n,f),qe(),y()}var sa=g(" "),ra=g('
        • '),na=g(' ',1),ia=g('

        Appeal recorded.

        '),la=g('

        No appealable veto in this receipt.

        '),oa=g('
        Claim

        Verdict

        Precedent
          Fix

          Appeal
          '),da=g('
          ');function ca(n,l){We(l,!0);const o=["PASS","NOTE","CAUTION","VETO","APPEALED"];let i=ne(null),x=ne(""),T=ne(!1),y=ne(null),N=ne(null),C=q(()=>{var u;return((u=e(i))==null?void 0:u.verdictBar)??(e(x)?"CAUTION":"NOTE")}),$=q(()=>{var u,f;return((u=e(i))==null?void 0:u.claims.find(M=>M.decision==="veto"))??((f=e(i))==null?void 0:f.claims.find(M=>M.decision==="appealed"))??null}),p=q(()=>{var u;return e($)??((u=e(i))==null?void 0:u.claims[0])??null}),c=q(()=>!!e(i)||!!e(x));Xe(()=>{E();const u=window.setInterval(E,4e3);return()=>window.clearInterval(u)});async function E(){var u;try{const f=await Ke.sanhedrin.latest();h(i,f.receipt,!0),h(x,""),((u=f.receipt)==null?void 0:u.verdictBar)==="VETO"&&f.receipt.id!==e(N)&&(h(T,!0),h(N,f.receipt.id,!0))}catch(f){h(x,f instanceof Error?f.message:String(f),!0)}}async function L(u){var f;if(!(!e($)||((f=e(i))==null?void 0:f.verdictBar)!=="VETO")){h(y,u,!0);try{const M=await Ke.sanhedrin.appeal(u,void 0,e($).id,e(i).id);h(i,M.receipt,!0),h(T,!0),h(x,"")}catch(M){h(x,M instanceof Error?M.message:String(M),!0)}finally{h(y,null)}}}function V(u){if(!u)return"";const f=new Date(u);return Number.isNaN(f.getTime())?"":f.toLocaleTimeString([],{hour:"2-digit",minute:"2-digit"})}function Z(u){var f;return(f=u==null?void 0:u.precedent)!=null&&f.length?u.precedent.map(M=>M.summary??M.command??"Precedent recorded.").slice(0,3):["No precedent attached."]}var z=Ze(),ae=le(z);{var de=u=>{var f=da(),M=a(f),he=s(a(M),2);Ie(he,21,()=>o,Ve,(S,F)=>{var _=sa();let K;var X=a(_,!0);t(_),I(()=>{we(_,"aria-current",e(F)===e(C)?"true":void 0),K=te(_,1,"svelte-1j425e6",null,K,{active:e(F)===e(C)}),m(X,e(F))}),v(S,_)}),t(he);var ge=s(he,2),Fe=a(ge);t(ge);var $e=s(ge,2),j=a($e);{var D=S=>{var F=et();I(()=>m(F,e(x))),v(S,F)},k=S=>{var F=et();I(()=>m(F,e(i).summary)),v(S,F)};G(j,S=>{e(x)?S(D):e(i)&&S(k,1)})}t($e);var se=s($e,2),Y=a(se,!0);t(se),t(M);var P=s(M,2);{var pe=S=>{var F=oa(),_=a(F),K=a(_),X=s(a(K),2),ce=a(X,!0);t(X),t(K);var ue=s(K,2),me=s(a(ue),2),be=a(me);t(me),t(ue);var J=s(ue,2),Ae=s(a(J),2);Ie(Ae,21,()=>Z(e(p)),Ve,(B,Q)=>{var U=ra(),ve=a(U,!0);t(U),I(()=>m(ve,e(Q))),v(B,U)}),t(Ae),t(J);var Ce=s(J,2),Ne=s(a(Ce),2),Te=a(Ne,!0);t(Ne),t(Ce),t(_);var Ee=s(_,2),Se=s(a(Ee),2);{var Oe=B=>{var Q=na(),U=le(Q),ve=a(U,!0);t(U);var r=s(U,2),d=a(r,!0);t(r);var A=s(r,2),R=a(A,!0);t(A),I((b,w,O)=>{U.disabled=b,m(ve,e(y)==="stale"?"Saving":"Stale"),r.disabled=w,m(d,e(y)==="wrong"?"Saving":"Wrong"),A.disabled=O,m(R,e(y)==="too_strict"?"Saving":"Too strict")},[()=>!!e(y),()=>!!e(y),()=>!!e(y)]),re("click",U,()=>L("stale")),re("click",r,()=>L("wrong")),re("click",A,()=>L("too_strict")),v(B,Q)},je=B=>{var Q=ia();v(B,Q)},Le=B=>{var Q=la();v(B,Q)};G(Se,B=>{e($)&&e(i).verdictBar==="VETO"?B(Oe):e(i).verdictBar==="APPEALED"?B(je,1):B(Le,!1)})}t(Ee),t(F),I(()=>{var B,Q,U,ve;m(ce,((B=e(p))==null?void 0:B.text)??e(i).draftPreview),m(be,`${((Q=e(p))==null?void 0:Q.decision)??e(i).overall??""} · ${((U=e(p))==null?void 0:U.evidence_state)??e(C)??""}`),m(Te,((ve=e(p))==null?void 0:ve.fix)||"No change required.")}),v(S,F)};G(P,S=>{e(T)&&e(i)&&S(pe)})}t(f),I((S,F)=>{te(f,1,S,"svelte-1j425e6"),we(M,"aria-expanded",e(T)),m(Fe,`Current verdict: ${e(C)??""}`),m(Y,F)},[()=>`verdict-bar tone-${e(C).toLowerCase()}`,()=>{var S;return V((S=e(i))==null?void 0:S.createdAt)}]),re("click",M,()=>h(T,!e(T))),v(u,f)};G(ae,u=>{e(c)&&u(de)})}v(n,z),qe()}ze(["click"]);const mt="vestige.theme",rt="vestige-theme-light",Re=vt("dark"),Ue=vt(!0),nt=Ct([Re,Ue],([n,l])=>n==="auto"?l?"dark":"light":n);function va(n){return n==="dark"||n==="light"||n==="auto"}function pa(n){if(va(n)){Re.set(n);try{localStorage.setItem(mt,n)}catch{}}}function Ye(){const n=pt(Re);pa(n==="dark"?"light":n==="light"?"auto":"dark")}function ua(){if(document.getElementById(rt))return;const n=document.createElement("style");n.id=rt,n.textContent=` +/* Vestige light-mode overrides — injected by theme.ts. + * Activated by [data-theme='light'] on . + * Tokens mirror the real names used in app.css so the cascade stays clean. */ +[data-theme='light'] { + /* Core surface palette (slate scale) */ + --color-void: #f8fafc; /* slate-50 — page background */ + --color-abyss: #f1f5f9; /* slate-100 */ + --color-deep: #e2e8f0; /* slate-200 */ + --color-surface: #f1f5f9; /* slate-100 */ + --color-elevated: #e2e8f0; /* slate-200 */ + --color-subtle: #cbd5e1; /* slate-300 */ + --color-muted: #94a3b8; /* slate-400 */ + --color-dim: #475569; /* slate-600 */ + --color-text: #0f172a; /* slate-900 */ + --color-bright: #020617; /* slate-950 */ +} + +/* Baseline body/html wiring — app.css sets these against the dark + * tokens; we just let the variables do the work. Reassert for clarity. */ +[data-theme='light'] html, +html[data-theme='light'] { + background: var(--color-void); + color: var(--color-text); +} + +/* Glass surfaces — recompose on a light canvas. The original alphas + * are tuned for dark; invert-and-tint for light so panels still read + * as elevated instead of vanishing. */ +[data-theme='light'] .glass { + background: rgba(255, 255, 255, 0.65); + border: 1px solid rgba(99, 102, 241, 0.12); + box-shadow: + inset 0 1px 0 0 rgba(255, 255, 255, 0.6), + 0 4px 24px rgba(15, 23, 42, 0.08); +} +[data-theme='light'] .glass-subtle { + background: rgba(255, 255, 255, 0.55); + border: 1px solid rgba(99, 102, 241, 0.1); + box-shadow: + inset 0 1px 0 0 rgba(255, 255, 255, 0.5), + 0 2px 12px rgba(15, 23, 42, 0.06); +} +[data-theme='light'] .glass-sidebar { + background: rgba(248, 250, 252, 0.82); + border-right: 1px solid rgba(99, 102, 241, 0.14); + box-shadow: + inset -1px 0 0 0 rgba(255, 255, 255, 0.4), + 4px 0 24px rgba(15, 23, 42, 0.08); +} +[data-theme='light'] .glass-panel { + background: rgba(255, 255, 255, 0.75); + border: 1px solid rgba(99, 102, 241, 0.14); + box-shadow: + inset 0 1px 0 0 rgba(255, 255, 255, 0.5), + 0 8px 32px rgba(15, 23, 42, 0.1); +} + +/* Halve glow intensity — neon accents stay recognizable without + * washing out on slate-50. */ +[data-theme='light'] .glow-synapse { + box-shadow: 0 0 10px rgba(99, 102, 241, 0.15), 0 0 30px rgba(99, 102, 241, 0.05); +} +[data-theme='light'] .glow-dream { + box-shadow: 0 0 10px rgba(168, 85, 247, 0.15), 0 0 30px rgba(168, 85, 247, 0.05); +} +[data-theme='light'] .glow-memory { + box-shadow: 0 0 10px rgba(59, 130, 246, 0.15), 0 0 30px rgba(59, 130, 246, 0.05); +} + +/* Ambient orbs are gorgeous on black and blinding on white. Tame them. */ +[data-theme='light'] .ambient-orb { + opacity: 0.18; + filter: blur(100px); +} + +/* Scrollbar recolor for the lighter surface. */ +[data-theme='light'] ::-webkit-scrollbar-thumb { + background: #cbd5e1; +} +[data-theme='light'] ::-webkit-scrollbar-thumb:hover { + background: #94a3b8; +} +`,document.head.appendChild(n)}function it(n){document.documentElement.dataset.theme=n}let ke=null,Me=null,_e=null,ye=null;function ma(){ke&&Me&&ke.removeEventListener("change",Me),ye==null||ye(),_e==null||_e(),ke=null,Me=null,ye=null,_e=null,ua();let n="dark";try{const l=localStorage.getItem(mt);(l==="dark"||l==="light"||l==="auto")&&(n=l)}catch{}return Re.set(n),ke=window.matchMedia("(prefers-color-scheme: dark)"),Ue.set(ke.matches),Me=l=>Ue.set(l.matches),ke.addEventListener("change",Me),it(pt(nt)),ye=nt.subscribe(it),_e=Re.subscribe(()=>{}),()=>{ke&&Me&&ke.removeEventListener("change",Me),ke=null,Me=null,ye==null||ye(),_e==null||_e(),ye=null,_e=null}}var fa=g('');function ha(n){const l=()=>oe(Re,"$theme",o),[o,i]=He(),x={dark:"Dark",light:"Light",auto:"Auto (system)"},T={dark:"light",light:"auto",auto:"dark"};let y=q(l),N=q(()=>T[e(y)]),C=q(()=>`Toggle theme: ${x[e(y)]} (click for ${x[e(N)]})`);var $=fa(),p=a($),c=a(p);let E;var L=s(c,2);let V;var Z=s(L,2);let z;t(p),t($),I(()=>{we($,"aria-label",e(C)),we($,"title",e(C)),we($,"data-mode",e(y)),E=te(c,0,"icon svelte-1cmi4dh",null,E,{active:e(y)==="dark"}),V=te(L,0,"icon svelte-1cmi4dh",null,V,{active:e(y)==="light"}),z=te(Z,0,"icon svelte-1cmi4dh",null,z,{active:e(y)==="auto"})}),re("click",$,function(...ae){Ye==null||Ye.apply(this,ae)}),v(n,$),i()}ze(["click"]);var ga=g(' '),ba=g('
          '),xa=g(''),ka=g(' '),_a=g('
          ',1),ya=g(''),wa=g('
          No matches
          '),$a=g('
          ◎ esc
          '),Aa=g(" ",1);function za(n,l){We(l,!0);const o=()=>oe(Tt,"$page",C),i=()=>oe(wt,"$isConnected",C),x=()=>oe(ot,"$memoryCount",C),T=()=>oe(dt,"$avgRetention",C),y=()=>oe(yt,"$uptimeSeconds",C),N=()=>oe(lt,"$suppressedCount",C),[C,$]=He();let p=ne(!1),c=ne(""),E=ne(void 0),L=q(()=>o().url.pathname.startsWith(xe)?o().url.pathname.slice(xe.length)||"/":o().url.pathname),V=q(()=>e(L)==="/waitlist"||e(L).startsWith("/waitlist/"));Xe(()=>{e(V)||st.connect();const j=ma();function D(k){if(e(V))return;if((k.metaKey||k.ctrlKey)&&k.key==="k"){k.preventDefault(),h(p,!e(p)),h(c,""),e(p)&&requestAnimationFrame(()=>{var P;return(P=e(E))==null?void 0:P.focus()});return}if(k.key==="Escape"&&e(p)){h(p,!1);return}if(k.target instanceof HTMLInputElement||k.target instanceof HTMLTextAreaElement)return;if(k.key==="/"){k.preventDefault();const P=document.querySelector('input[type="text"]');P==null||P.focus();return}const Y={g:"/graph",m:"/memories",t:"/timeline",f:"/feed",e:"/explore",i:"/intentions",s:"/stats",r:"/reasoning",a:"/activation",d:"/dreams",c:"/schedule",p:"/importance",u:"/duplicates",x:"/contradictions",n:"/patterns"}[k.key.toLowerCase()];Y&&!k.metaKey&&!k.ctrlKey&&!k.altKey&&(k.preventDefault(),at(`${xe}${Y}`))}return window.addEventListener("keydown",D),()=>{st.disconnect(),window.removeEventListener("keydown",D),j()}});const Z=[{href:"/graph",label:"Graph",icon:"◎",shortcut:"G"},{href:"/reasoning",label:"Reasoning",icon:"✦",shortcut:"R"},{href:"/memories",label:"Memories",icon:"◈",shortcut:"M"},{href:"/timeline",label:"Timeline",icon:"◷",shortcut:"T"},{href:"/feed",label:"Feed",icon:"◉",shortcut:"F"},{href:"/explore",label:"Explore",icon:"◬",shortcut:"E"},{href:"/activation",label:"Activation",icon:"◈",shortcut:"A"},{href:"/dreams",label:"Dreams",icon:"✧",shortcut:"D"},{href:"/schedule",label:"Schedule",icon:"◷",shortcut:"C"},{href:"/importance",label:"Importance",icon:"◎",shortcut:"P"},{href:"/duplicates",label:"Duplicates",icon:"◉",shortcut:"U"},{href:"/contradictions",label:"Contradictions",icon:"⚠",shortcut:"X"},{href:"/patterns",label:"Patterns",icon:"▦",shortcut:"N"},{href:"/intentions",label:"Intentions",icon:"◇",shortcut:"I"},{href:"/stats",label:"Stats",icon:"◫",shortcut:"S"},{href:"/settings",label:"Settings",icon:"⚙",shortcut:","}],z=Z.slice(0,5);function ae(j,D){const k=D.startsWith(xe)?D.slice(xe.length)||"/":D;return j==="/graph"?k==="/"||k==="/graph":k.startsWith(j)}let de=q(()=>e(c)?Z.filter(j=>j.label.toLowerCase().includes(e(c).toLowerCase())):Z);function u(j){h(p,!1),h(c,""),at(`${xe}${j}`)}var f=Aa(),M=le(f);{var he=j=>{var D=Ze(),k=le(D);tt(k,()=>l.children),v(j,D)},ge=j=>{var D=_a(),k=s(le(D),6),se=a(k),Y=a(se),P=s(Y,2);Ie(P,21,()=>Z,Ve,(b,w)=>{const O=q(()=>ae(e(w).href,o().url.pathname));var H=ga(),W=a(H),ee=a(W,!0);t(W);var ie=s(W,2),Pe=a(ie,!0);t(ie);var Je=s(ie,2),ft=a(Je,!0);t(Je),t(H),I(()=>{we(H,"href",`${xe??""}${e(w).href??""}`),te(H,1,`flex items-center gap-3 px-3 py-2.5 rounded-lg transition-all duration-200 text-sm + ${e(O)?"bg-synapse/15 text-synapse-glow border border-synapse/30 shadow-[0_0_12px_rgba(99,102,241,0.15)] nav-active-border":"text-dim hover:text-text hover:bg-white/[0.03] border border-transparent"}`),m(ee,e(w).icon),m(Pe,e(w).label),m(ft,e(w).shortcut)}),v(b,H)}),t(P);var pe=s(P,2),S=a(pe);t(pe);var F=s(pe,2),_=a(F),K=a(_),X=s(K,2),ce=a(X,!0);t(X);var ue=s(X,2),me=a(ue);ha(me),t(ue),t(_);var be=s(_,2),J=a(be),Ae=a(J);t(J);var Ce=s(J,2),Ne=a(Ce);t(Ce);var Te=s(Ce,2);{var Ee=b=>{var w=ba(),O=a(w);t(w),I(H=>m(O,`up ${H??""}`),[()=>$t(y())]),v(b,w)};G(Te,b=>{y()>0&&b(Ee)})}t(be);var Se=s(be,2);{var Oe=b=>{var w=xa(),O=a(w);St(O),t(w),v(b,w)};G(Se,b=>{N()>0&&b(Oe)})}t(F),t(se);var je=s(se,2),Le=a(je);aa(Le,{});var B=s(Le,2);ca(B,{});var Q=s(B,2),U=a(Q);tt(U,()=>l.children),t(Q),t(je);var ve=s(je,2),r=a(ve),d=a(r);Ie(d,17,()=>z,Ve,(b,w)=>{const O=q(()=>ae(e(w).href,o().url.pathname));var H=ka(),W=a(H),ee=a(W,!0);t(W);var ie=s(W,2),Pe=a(ie,!0);t(ie),t(H),I(()=>{we(H,"href",`${xe??""}${e(w).href??""}`),te(H,1,`flex flex-col items-center gap-0.5 px-3 py-2 rounded-lg transition-all min-w-[3.5rem] + ${e(O)?"text-synapse-glow":"text-muted"}`),m(ee,e(w).icon),m(Pe,e(w).label)}),v(b,H)});var A=s(d,2);t(r),t(ve),t(k);var R=s(k,2);It(R,{}),I(b=>{we(Y,"href",`${xe??""}/graph`),te(K,1,`w-2 h-2 rounded-full ${i()?"bg-recall animate-pulse-glow":"bg-decay"}`),m(ce,i()?"Connected":"Offline"),m(Ae,`${x()??""} memories`),m(Ne,`${b??""}% retention`)},[()=>(T()*100).toFixed(0)]),re("click",S,()=>{h(p,!0),h(c,""),requestAnimationFrame(()=>{var b;return(b=e(E))==null?void 0:b.focus()})}),re("click",A,()=>{h(p,!0),h(c,""),requestAnimationFrame(()=>{var b;return(b=e(E))==null?void 0:b.focus()})}),v(j,D)};G(M,j=>{e(V)?j(he):j(ge,!1)})}var Fe=s(M,2);{var $e=j=>{var D=$a(),k=a(D),se=a(k),Y=s(a(se),2);gt(Y),xt(Y,_=>h(E,_),()=>e(E)),fe(2),t(se);var P=s(se,2),pe=a(P);Ie(pe,17,()=>e(de),Ve,(_,K)=>{var X=ya(),ce=a(X),ue=a(ce,!0);t(ce);var me=s(ce,2),be=a(me,!0);t(me);var J=s(me,2),Ae=a(J,!0);t(J),t(X),I(()=>{m(ue,e(K).icon),m(be,e(K).label),m(Ae,e(K).shortcut)}),re("click",X,()=>u(e(K).href)),v(_,X)});var S=s(pe,2);{var F=_=>{var K=wa();v(_,K)};G(S,_=>{e(de).length===0&&_(F)})}t(P),t(k),t(D),re("keydown",D,_=>{_.key==="Escape"&&h(p,!1)}),re("click",D,_=>{_.target===_.currentTarget&&h(p,!1)}),re("keydown",Y,_=>{_.key==="Enter"&&e(de).length>0&&u(e(de)[0].href)}),bt(Y,()=>e(c),_=>h(c,_)),v(j,D)};G(Fe,j=>{e(p)&&!e(V)&&j($e)})}v(n,f),qe(),$()}ze(["click","keydown"]);export{za as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js.br b/apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js.br new file mode 100644 index 0000000000000000000000000000000000000000..17966bc969a99f799631b3afd5143d57b8ba9267 GIT binary patch literal 9928 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 G2Y&&ZI6^c4 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js.gz b/apps/dashboard/build/_app/immutable/nodes/0.j0CpgSFp.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..6d56e43be141c057bbb9fff167dd455dec965b8a GIT binary patch literal 11290 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 diff --git a/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.gz b/apps/dashboard/build/_app/immutable/nodes/1.CJFfVX1H.js.gz deleted file mode 100644 index a10aac2f9637fbacf920009cfdde2d5d62f216e2..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 383 zcmV-_0f7D=iwFP!000026J?OiPQx$|gzr3ssW{lul2U{~BDe@j1qXf(2r9TB<2Z>) zVq3OTsz!Nt;-IUxhNKB(25FE4e2@}YkToPh9M~WlM3ArlnG3TjR;w31%yfY?qweK<`Z#-9 z4#~dJX4m~_6#ej`%$e4sajXC2-97&(Z*G1^Llh(OIJ^7YKA-m_*UEYHO`A-3B&^jI zlg0{PTZO8qFSHOm=b5kF(A-tpHZG#tB+QE>;<@0(K2y@~c+D(Y(jz>%%4c(QHSJFm zZe~7#8Hv+caWAz(3!H)?O@z(kX$u z^Vr^F1WJqvoi_myvB4bVep~_u*MJ3;yU!6yRb7_XYb_IWaw(!pIL9(US^}GHrmpQ8 dlU8i{g)YKEx$d^Bgz{~C@CON

          ",1);function C(f,n){g(n,!1),h();var t=E(),r=d(t),c=s(r,!0);o(r);var a=_(r,2),u=s(a,!0);o(a),l(()=>{var e;p(c,i.status),p(u,(e=i.error)==null?void 0:e.message)}),x(f,t),v()}export{C as component}; +import"../chunks/Bzak7iHL.js";import{i as h}from"../chunks/BUoSzNdg.js";import{p as g,f as d,t as l,a as v,d as s,r as o,e as _}from"../chunks/CpWkWWOo.js";import{s as p}from"../chunks/BlVfL1ME.js";import{a as x,f as $}from"../chunks/CHOnp4oo.js";import{p as m}from"../chunks/D8UfWY0j.js";import{s as k}from"../chunks/C2TQQEIa.js";const b={get error(){return m.error},get status(){return m.status}};k.updated.check;const i=b;var E=$("

          ",1);function C(f,n){g(n,!1),h();var t=E(),r=d(t),c=s(r,!0);o(r);var a=_(r,2),u=s(a,!0);o(a),l(()=>{var e;p(c,i.status),p(u,(e=i.error)==null?void 0:e.message)}),x(f,t),v()}export{C as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/1.DEUqmURt.js.br b/apps/dashboard/build/_app/immutable/nodes/1.DEUqmURt.js.br new file mode 100644 index 0000000000000000000000000000000000000000..894d776fd98e6b6f5ad04f29edebf33e145dd7dc GIT binary patch literal 340 zcmV-a0jvHSi2`7Z!nS$yk!2b#7D*CE5)I9(e`$333@GiS$?!RSHm#-89X#?EK`=(Q zsUSEOK`8nEZ@xD`u4rPJJ;yt8VDl)OBs7W{d}XpBEU z=ew^(0rg$(P9wEvicd!lxQA%miz@2vK8p+Cl!rNt0wDqegaiU10k}}21uC%gzWV#U zx>QK^hDVtXJ5A4P3NjhFfsNc<9q;B+96GQV8lBp;zEcr_PQ1D?{ykKTxAq#JyG3s>db##_AJz?a0AB?A% m4lTJl?5eZFerM`r@>tiwFP!000026J=0cOT#b}efL+yv4;dM-6n!!mkG{+f***^;nT?4w2f_( zkfdW+`rmE3J(Tq&C){&#&dC*}R>qBjU=n4O%kY0QzFSFNG zU)cp6j_Kop_0zl5*GdiQmgmaH+jX+}nf?w+t in i?Bc(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e;var kt=(i,t,e)=>zc(i,typeof t!="symbol"?t+"":t,e);import"../chunks/Bzak7iHL.js";import{o as jl,a as Zl}from"../chunks/GG5zm9kr.js";import{s as me,c as va,h as zt,g as B,p as ys,aB as kc,a as Es,d as yt,e as bt,n as Hc,r as xt,t as Ke,u as Gn,f as Kl,j as Vc}from"../chunks/CpWkWWOo.js";import{s as fe,d as $l,a as Fe}from"../chunks/BlVfL1ME.js";import{i as kn}from"../chunks/B4yTwGkE.js";import{e as _s,i as hr}from"../chunks/CGEBXrjl.js";import{a as _e,f as Se,c as Gc}from"../chunks/CHOnp4oo.js";import{s as ve,r as xa}from"../chunks/A7po6GxK.js";import{s as Us}from"../chunks/aVbAZ-t7.js";import{s as Sr}from"../chunks/Cx-f-Pzo.js";import{b as Ma}from"../chunks/sZcqyNBA.js";import{b as Jl}from"../chunks/BnXDGOmJ.js";import{s as Wc,a as Xc}from"../chunks/C6HuKgyx.js";import{b as Do}from"../chunks/DGcYlAAw.js";import{b as Yc}from"../chunks/CJsMJEun.js";import{p as vs}from"../chunks/V6gjw5Ec.js";import{N as Sa}from"../chunks/CcUbQ_Wl.js";import{i as qc}from"../chunks/BUoSzNdg.js";import{a as gi}from"../chunks/554JRhq6.js";import{e as jc}from"../chunks/MAY1QfFZ.js";/** +var Bc=Object.defineProperty;var zc=(i,t,e)=>t in i?Bc(i,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):i[t]=e;var kt=(i,t,e)=>zc(i,typeof t!="symbol"?t+"":t,e);import"../chunks/Bzak7iHL.js";import{o as jl,a as Zl}from"../chunks/GG5zm9kr.js";import{s as me,c as va,h as zt,g as B,p as ys,aB as kc,a as Es,d as yt,e as bt,n as Hc,r as xt,t as Ke,u as Gn,f as Kl,j as Vc}from"../chunks/CpWkWWOo.js";import{s as fe,d as $l,a as Fe}from"../chunks/BlVfL1ME.js";import{i as kn}from"../chunks/B4yTwGkE.js";import{e as _s,i as hr}from"../chunks/CGEBXrjl.js";import{a as _e,f as Se,c as Gc}from"../chunks/CHOnp4oo.js";import{s as ve,r as xa}from"../chunks/A7po6GxK.js";import{s as Us}from"../chunks/aVbAZ-t7.js";import{s as Sr}from"../chunks/Cx-f-Pzo.js";import{b as Ma}from"../chunks/sZcqyNBA.js";import{b as Jl}from"../chunks/BnXDGOmJ.js";import{s as Wc,a as Xc}from"../chunks/C6HuKgyx.js";import{b as Do}from"../chunks/D8UfWY0j.js";import{b as Yc}from"../chunks/CJsMJEun.js";import{p as vs}from"../chunks/V6gjw5Ec.js";import{N as Sa}from"../chunks/CcUbQ_Wl.js";import{i as qc}from"../chunks/BUoSzNdg.js";import{a as gi}from"../chunks/B7CfdQuM.js";import{e as jc}from"../chunks/MAY1QfFZ.js";/** * @license * Copyright 2010-2024 Three.js Authors * SPDX-License-Identifier: MIT diff --git a/apps/dashboard/build/_app/immutable/nodes/10.CACwABbv.js.br b/apps/dashboard/build/_app/immutable/nodes/10.CACwABbv.js.br new file mode 100644 index 0000000000000000000000000000000000000000..ddad2ebbe25ae6b28ff72eb7803988aa6ed949cd GIT binary patch literal 124073 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

          S5 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

          h)Q_WJg&Tfk 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

          D$SaLt;VYOByYwyQq@6vt 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

          Bp!Jx~(nVUwMX2~!kP&T2 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

          `);function Ft(Be,Ee){ct(Ee,!0);let q,G=p(""),j=p(""),I=p("solo"),J=p("sync"),x=p(""),H=p(""),y=p("idle"),_=p(""),S=p(""),T=p(!1),C=p(mt([{role:"bot",content:"Ask me about installing Vestige, whether heavy models are required, Solo vs Team Pro, sync, pricing, or what happens after you join the June list."}]));const Fe=[{value:"Local",label:"SQLite memory, no hosted memory service"},{value:"MCP",label:"Claude Code, Cursor, Cline, Codex, Goose"},{value:"June",label:"Pro sync, backup, team memory early access"}],De=[{name:"Solo Pro",accent:"#22c55e",copy:"Multi-device sync, encrypted backups, managed updates, and a cleaner memory dashboard for developers living inside AI coding agents."},{name:"Team Pro",accent:"#06b6d4",copy:"Shared project memory, admin review, audit trails, PostgreSQL-backed deployments, and async support for engineering teams."}],Oe=["Private by default","Sync without lock-in","Team memory controls","Bot-assisted support"],ze=[{label:"Install",prompt:"How do I install Vestige and connect it to Claude Code?"},{label:"No 20GB?",prompt:"Do I need the Sanhedrin model or 20GB of RAM?"},{label:"Solo vs Team",prompt:"Should I choose Solo Pro or Team Pro?"},{label:"Sync",prompt:"How will Pro sync and backups work?"},{label:"Pricing",prompt:"How much will Vestige Pro cost?"},{label:"Human help",prompt:"When does a human get involved?"}];it(()=>{const t=q.getContext("2d");if(!t)return;const e=t;let r=0,i=0,m=0;const d=Array.from({length:62},(b,w)=>({x:Math.random(),y:Math.random(),vx:(Math.random()-.5)*16e-5,vy:(Math.random()-.5)*16e-5,phase:Math.random()*Math.PI*2,kind:w%5}));function M(){const b=Math.min(window.devicePixelRatio||1,2);i=window.innerWidth,m=window.innerHeight,q.width=Math.floor(i*b),q.height=Math.floor(m*b),q.style.width=`${i}px`,q.style.height=`${m}px`,e.setTransform(b,0,0,b,0,0)}function Me(b){e.clearRect(0,0,i,m);const w=e.createLinearGradient(0,0,i,m);w.addColorStop(0,"#07100f"),w.addColorStop(.45,"#0b1221"),w.addColorStop(1,"#15100a"),e.fillStyle=w,e.fillRect(0,0,i,m),e.strokeStyle="rgba(148, 163, 184, 0.08)",e.lineWidth=1;for(let n=0;n.96)&&(n.vx*=-1),(n.y<.06||n.y>.94)&&(n.vy*=-1);for(let n=0;n{cancelAnimationFrame(r),window.removeEventListener("resize",M)}});function Ne(){const t=["## Vestige Pro waitlist","",`Plan: ${a(I)}`,`Priority: ${a(J)}`,a(x).trim()?`Use case: ${a(x).trim()}`:"Use case:","","Please do not include private email addresses in this public issue."].join(` `);return`https://github.com/samvallad33/vestige/issues/new?title=${encodeURIComponent("Vestige Pro waitlist")}&body=${encodeURIComponent(t)}`}async function Ye(t){if(t.preventDefault(),c(y,"submitting"),c(_,""),a(H).trim()){c(y,"success"),c(_,"You are on the list.");return}if(!a(j).includes("@")){c(y,"error"),c(_,"Enter an email so the early-access invite can reach you.");return}a(G).trim(),a(j).trim(),a(I),a(J),a(x).trim(),new Date().toISOString();{c(y,"success"),c(_,"Email capture is ready for an endpoint. Opening the GitHub waitlist fallback with your email omitted."),window.open(Ne(),"_blank","noopener,noreferrer");return}}function Ke(t){const e=t.toLowerCase();return/(install|setup|onboard|claude|cursor|cline|codex|connect)/.test(e)?["Start with the open-source install:","1. `npm install -g vestige-mcp-server@latest`","2. Claude Code: `claude mcp add vestige vestige-mcp -s user`","3. Codex: `codex mcp add vestige -- vestige-mcp`","Then test it by asking your agent to remember a preference, opening a fresh session, and asking for that preference back."].join(` diff --git a/apps/dashboard/build/_app/immutable/nodes/20.DebghJca.js.br b/apps/dashboard/build/_app/immutable/nodes/20.DebghJca.js.br new file mode 100644 index 0000000000000000000000000000000000000000..cc2dc08b25f5b1aac8fe5ddb7cfbb96e85ba7cd0 GIT binary patch literal 5511 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 JCm3r)+yHuFv8@0A literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/20.DebghJca.js.gz b/apps/dashboard/build/_app/immutable/nodes/20.DebghJca.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..6c1b8e82e36d78302c9d835985b028ffa852f502 GIT binary patch literal 6455 zcmV-78OY`ziwFP!000026SZ7@Thqwe|NA+gBAfNuljt;15Ou-oK~zLRP*7IAydZ6+ zZ6L{nWZF_mzx(sMXC`U-0(#D~XZPCXW$u}|-`^%|7^fnWw&$&M`h(;$UwQGvzkD3N z+4nATdn;6gELb?nVkl9I3FHcVoMI9NnVBf6&for6O zdi(am3NND1-TmgltNIFRvs1nR`fz+Q+P$0sRht}X^ez{$+kN%ouk0eKPf%zKSXUvr zFyYN%l0FnOa~bxyb(9Hfx!i(qPP>uG=e zj_v#F_)YHsNU@H=itxPFc-}n&aL1Y%gn`Bb{5V!!LkN(R zP$X^PX8}DXLh{`6JdLyA>yF;DJ&;mBZO19}T0hu#kf0%G{sGNDuj5>*dL!@iC|bn3 z<0nJ%-Wpo#HjIHs!91+xXQAKdhe5y-lH`Ds(DZy@QQK2ZZw$j;!lmTDwvG`#_XD0) z+9J|6Onm`ozY<7BmbP^L$ZzwgWiPe*zKChhy1A&88nK@(>hEV`IoiIS)mE%b%Ew^h z4`+5hEqB8}*z=8BS}sFS)X#XgW%s2_^Ual&UMTy6w$~ByO76!)KZ^WdeSKx9_qHwR zXFU$@cGiyk+A$GWgJ&7fZrx}%ly3%Yjj(?k&`Uq>D>a>i10jtL-0eKSHR``# zz|-2#$luburz-%*ua+p5iT&_a=kzq^9b!;9-sce4?P861&>m~3h6I=StdmjiJ0cz5 zVWoV`+nE?GK)fBmHE}XYGwABI&JD z&_Bm_1hm_t7J_Nat%P4oPjh3Q*S->7ey1TGWg)DKxT;|5R-Eb~3JaG%S1#p8D^u1+ zyu_n4{^-fA83Uc_J4bd9{A9w>vxPXIhVP2e1kfO}r6~35aqiWk(X8DD`;q578$x51U(UHNVJmAD z1&Y|)eZ?JF&U<8nmAej;bbvBuAO)nCMqG08VQ~E>Vbu3&yo?t*Tel-X)4*CCg2{|P{lyM8# zSna`>lm(jed>Sly1gCDu$iy8k^Qllt`?F&a3GFw{i*n$EywuFVieCM1BE(0&?;}%z zpN)~!-$Dc2l*mFk{wW;?gGh!AIPb8-RRys?&~YD}3+mo?0c2WTSSwZs9z26%S9L}b zEC9b);_T@b;k(aXZ%=NVkOJb^Ro{Rctlv_DoMgOQGmUvGavr9M)*F%2PQ>5G}<7+Rq6Frb78QY+`J`PKm(1dr}a zy$A{f$w6-2>6HmC3VVI|YqfQ~d_A0U3ad=VVj}L2-Vu%8Mp%rL4@PoZ0T2!;dWwi# z<1@G^>t+I(i1Us`@! z09@%@6fx5rL|V`R7R*AmRVFI47}L~x2eM`&w?_hNwh3gM`)v}!7M0hpJpNC7OeXvw z_S2vH7X$eB_?QEKOom8x_KbI#-Q+G0LoS+}LLRCNc*gyT+q0S|yglK$v%?CEf3e59 z%csRSJOaYdkRxOq>>M#`C-MgYw{}Fp@i548kug)QZ|^bdBMNz4fg@S#HjIzyz=M*{ zkd&f!knQ9~2kRlptE${6q$KD+rBjRKmk8ZUhU7=5Zn;d|6$PagAm<}TtT-{(NY8Zw ze0wV$;WZNDm^v4CwA244%D21l+`mXVCBUjp)8()Z>UV=WImnVq@+x-th(D1S0#_|# zDWIB)6Tu+!se`OU*f3c|m~=BA`wu!;iqFu6JU*(K@zWJ*q#1=jcelDo%9K^Vmd*># zUUB!PBb`^A{kH0EA>*{J*lsIzY};iQ=DJ7M91_F*TXhfN;Qrc-zcJS_T|-20+@G0u z$L4y1>u*h$?cf?q=i3ccc$?&FZD!71HkIRx`K;R{hiy2;s3L$4Wfl^>;TW}7z@uCh zm1Pmjv}O(SN~xB)-4U5b-%pW|VLAy@rD+#sw@5YhsQKa9lkcv(1q7k9uX*d+&Crhq zzzm1O0-qB z8T$!zGq46}fQ-hNA2rW7@|Uc{BPg51^PNhBdy+B49fAwndnoF3UZ&fSM72h@3YJrJ zS0A+>1rJMfO_hwi;DV~~s!bWhkZT4i_y|vfAe0tz?J&xJ$&vU(col;Qd7ktj9G8 zzEKFeN?q43UTdH=64_;a?vXb2+3E2BwWwO7e#FzE_DyZ-n*p>L?j=g6vrqdR<(r^b zYW3B4kCS^EiU|H1v%hbJ(sA6@vm5OwWb4WU$c}DKIQCj#yIWz``AxbRC)aNr3U5i} zakJJc3-MpvS~Vje)AD;Y_Q?@_OTR&51(D@zIr;^yT8UR!z9=o{qM%atp$<;$2EkvTM88B z=8OO-MxOQ^N8vS(KGKm^Q8d{an9(xhAyhLv4FlN+_4RjeIF&2x${W$3Ubhm`zPhTnSlB=d zCm|mdxQTcDpp|&TYnFIpbvI@XUOx3!9~K2}o_T*ha{u_lA(;EE267eLjxqd*hQ}Cw zXokmXc#ej^(`E`%9+dX5-3q=X-`Ty^ws(C$WFK%H-;b+_0dFM_np**%P7Zi&HpldU ze`lY0Yn!VTF4P^?V0*lEuko3)x4iYCalzR>*QStPWzyN>_xJdNxBUKFt{l%kf7*QX zq+B+`CES#3gfCDxiDpLrp-y>VnsW zF_}#C&XGijta6NL__lxVZv4qt+jPgf5AhG(`Rn}A`iA{|QI-{Zy^XrE{YjeODGvs^ zHo*79@I6s{ubWFGza<{Iv+qE(7m2nXZAX~eg84nzzVEGXED-Bw9io&qy+?p(dQV_v zm1``GQ9;(%YfiEjWv2)_+esL!bN$yD5*p`#yAvG`$b~ZF{b22{hVUKxlmNgHIyS1f z@CW#H;IccGVmbi%Nry*sqgl0h#z|tgu0NU7-1>W7`E@0>-qKXk6~n)9yuN|CN-ssW3b2CG9V!pe8vl=tAy&LvK4COLM^Ati-s;QC?}#iNHs^fk9-SNRc$Zd*)36JYR~F^ zkAB{|btPe7y7dx5cJM~*9UmS`O1R84gF0)StpQ@H9hM*N#m+?X!Iyhfuwm8P6f0#4gg34_YY&(-&FwSz&_ zHE?Y_Zj*+>I}rO}bts^Pk+*Mk;UoGe#Zg*`q%7?&%`vp@m`x|D+G56YY_2$YSpyYo ztGzaUEd0X57OEXlsKTg-qw9j!QSJ5u#m;3-CMdH!i+Yl#IILW1ia1gpT<8YS!Ol^= zeZVtsT7xmG+QFh7Or;vprzK`OCWPIP%I|5DM4#{ak*CWjU6Ik5YDv90ze)r-t`b0% zfWEHwVi+}ji+Mqx5lPjsE1QZoF$igDK^1X9J=cQ1(>Jdh4OA$-W`by?>-s}& zk}kqa*rS892wJ9_y-Lh&V^$3;6-t-%60W|;CK z!V*xpLA&~-8|IkEel#w|Dn!*8X8Hrf2TCfsA?eJRON}m^Yeqh0_Sj%^s;}fO5Cy_v z7z{9R+R9>6&Ma>eS&QGJA&lw{on{Bo4`obw*{>{*C8upkb*ipdqm{oHq&?J|Dk?-p z#>>b74?v!-PB`UO=cS+3v(GiEbo_0)a5OpBtmp~Qr@Ru}gGR7)3gDaW4GHZ*r~{|I z$N&=b{a*}e=9QmNdT1D1N_FUW#)Z<&LhHWdkRq4axBy~)p;XknPa4Hx7*}*0SSO}b z^$xK|LFJ_;m8Y^`wrS0hZmAYdg}A@GM?2#iDJ;PTkcx#WDEOHeB*9#>wf3c@Y4K46 zCtj3U>dZ%$s;BQ;NE(o6!1A?Y&HDD9W?Nf;v)#Kg2sa3n=`Ne+l0a z<{&<(GiClny(C1PaVxnX1DQXNgraLQmYtE7N9NJkv))kqmXh;I4|opJh(?uVn9p%Y zsmoRwaV91Jkw75z1Ad)bYu)lYa-bxpM5AY341!)<>Pu-a#RY7jP!>~YODJ^GS*SLC zofX@Qef@G3HZ`Z2{Iwg=0i>qPS2`t*! zNL;EvsqAUV2MU$=;l0C1y9CVxi=@DFaLV3OE`-!Yi=>iu6)DRsVCE3z_H&ae7#NeS zousJK$MUNNtq54zvtEPdM2s|-yMC@xw?rw11ZkoAvSL9fYPqt&Q+dF^l!9fgp#)ZA z3{h%6vO@t|lMpq8NtV=@pDVIbWZ#UtH?q}A2Jn)_VzFhKdRfci&!79wv0IiTs)y_R zmKBBXoVcn;I#xAU$2p>+PO&PR8vE1e;yHLqGywHL1R_@`D*0}nBcAV0aR&+%%&*_zA#qT9&nbC(*u_qc<1 zLOlvVs`+gK`9#1kFujeTSGc}#*;vng<+3O4){!&Df=#vYYtAm2LeUVIwa%z44lyrt zS&U1l_$r)G@6p3bA#D+0tY^l0gaqKbhAmEvij%vZI#qMo&D6Cj^;fj|ONH=jqLuYD_AeFTr%q2zc&R5GV(29Sbv4kT0qQECLk;u;Lx%+PUcvlO zt9}9g@7=908p+ld@9a$9=@VJ~w{5iO7kBH58z|gVU{amK2rPo1A9|;Efd8SSrFMF! zcKV8){&Kgznl--GcA~==HIdU!U)?QU?!@PIG6&QeS`swp?v^aUWevPcY&Gl|!6L$M zot3a>HQ3tsZA8moM9Vu(i%%2Z5dkC3TVJc*KsqDET|6tmoQ8d+q(>Su=SB=i3NSZ- z`xwj>+*i`?eWN}5dX!5H@6$Y`iBh(vRyQK6Q%5=ql+=@(*}PJ_to4TDb+c^fl%GS* zfBM46L9vY8m{!N8?~L76t5vl=nCj0|uXVR(LV6rRkI!6pYS>$+*itJ0KqG(rAss0( zJ`tq60>-Bh7Q~kqMB9-gD(gF3w7#Rt`V4uMRq4$+++*E(gkfz)8wkbQOD%&;%izel ztoD1kxZkDTPfbwD`X8EnPXgofMnivV*`Z?<-GhYH>r>^)IWf>U20D1I`2|XH=iI`j z(wxkYcTF^9io9b@-nAl+QODUi#{G$Y9pM)K)0cRCQmV*_S}QVZB??llwL`NLPF&i7 z;yhMdQjuexPsgPKhJejVh8pBmVDa)4nY3zY(CnD?%Gp8dnz(#`y#j+#FqP^7SkTi_ zjai_HulO30N@q%?m+5fGZfbuEX>TfgDCUvcDw9@Wa{0Ilpp%+9X=5fU+~JiOin0{qBLI^%})%cL*jJ8wHk(%8va;R!=0b1y@?$zYa=dqP&{ASFkyl~<}nmu zV6AF6eY!krC80s6LkNXR^f8IP!^ug-r4143u|ikS5GEe0U(&TQ;I`G9kAxnPzRM{* z+w`YOHaov}^NCMZ%ESwbfZ@O9hf!3feT?mUs52<-3|dnMR5hYu9A7zGGVt6!_UXe8 z^1uW zdOsuP8hzh&N#Y%6ml2CUBhH$E3o~$`20n7@m~2@Pac4Er6a)`qKGkROmY*uIh^1yjK68g-&^p RFxmRY{{e?cRny=>0030gzLfv~ literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js b/apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js similarity index 56% rename from apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js rename to apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js index 28965de..3cca1e6 100644 --- a/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js +++ b/apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js @@ -1 +1 @@ -import"../chunks/Bzak7iHL.js";import{i as p}from"../chunks/BUoSzNdg.js";import{o as r}from"../chunks/GG5zm9kr.js";import{p as t,a}from"../chunks/CpWkWWOo.js";import{g as m}from"../chunks/D-gDZzN6.js";function g(i,o){t(o,!1),r(()=>m("/graph",{replaceState:!0})),p(),a()}export{g as component}; +import"../chunks/Bzak7iHL.js";import{i as p}from"../chunks/BUoSzNdg.js";import{o as r}from"../chunks/GG5zm9kr.js";import{p as t,a}from"../chunks/CpWkWWOo.js";import{g as m}from"../chunks/C2TQQEIa.js";function g(i,o){t(o,!1),r(()=>m("/graph",{replaceState:!0})),p(),a()}export{g as component}; diff --git a/apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js.br b/apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js.br new file mode 100644 index 0000000000000000000000000000000000000000..ca7f12cac7edc5108dfb541364cb935705dd5ab5 GIT binary patch literal 164 zcmV;V09*eXBmp30aZZ1uwyNYrs0ReM+4-3!mRT6r7I<4ESsLIg{~r0>#&CI_QWVjO zym!~6TCH(%U}|1%nKD{W*`KSbM@B-+6pHaE`yX+bq>uGVue=0{b(P(&lNtlfg?;qP z43(Ar(|*631!*@xoA1YCb6}#rcL|iTg_#dlnQma&1;EMF08;ztUZk9DJv)Z_8`AYZ SV%Y{PGk|{~&J^>I|4{*`tWg;N literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js.gz b/apps/dashboard/build/_app/immutable/nodes/3.Bu_uPddU.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..09e598a395f59283bca63ba2e82fbdc362712b91 GIT binary patch literal 197 zcmV;$06PC4iwFP!000026J^ao3xY5hfZ=<;LOpFTw1S9|Iuv0+6k_3d*wkg)H|B&; z{O_fg#Ln*nFBb~5aa`9+@=6w^x2tKfmE!CzP#8BQLsxOahD4~;j zEQ4TCi&deAQgzZ0I<|Wi7jb-rq0Krg{^a}?hKCdFWm?I^aFAApI04)k1jL?Uq7lNI ztw4^KX{vIEG@7XwO;}{8VQYKZVoVgmgd*Is_ivZL_br(;tv~qy-fPkrB>?~c6MtHf literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.br b/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.br deleted file mode 100644 index 840c5ed9ce2d6e1e2301267de55de990d59e264d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 165 zcmV;W09yYWBmp30aZZ1uwyN}mr-3t|yt!Kwje|@r= TVO%r;7b(CQ7iNli$ZU`U3Gqku diff --git a/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.gz b/apps/dashboard/build/_app/immutable/nodes/3.mK8D6pz1.js.gz deleted file mode 100644 index 3482e9c2dbfb793264218c55ac114fa53b182b71..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 198 zcmV;%06G63iwFP!000026J5*WxHVZ1%ZKqt0e&d07igW AS^xk5 diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.br b/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.br deleted file mode 100644 index 715e2abd6662c90c4ac6f2c5543d7d6028c5d80a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4437 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 b2f{h-ns&VK)pugyqegR3mc^NN5H0o(n%Sov diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.gz b/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js.gz deleted file mode 100644 index 6cf01ba109d5b61fbf7512c0615bc0a91767d7f9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4976 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 diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js b/apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js similarity index 99% rename from apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js rename to apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js index eb053c8..f4d960a 100644 --- a/apps/dashboard/build/_app/immutable/nodes/4.DPhwyLUO.js +++ b/apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js @@ -1,4 +1,4 @@ -import"../chunks/Bzak7iHL.js";import{o as we,a as Ne}from"../chunks/GG5zm9kr.js";import{p as Me,s as A,c as le,aB as ve,e as y,d as p,t as L,g as e,f as Ee,u as de,r as v,a as Se,h as d,n as me}from"../chunks/CpWkWWOo.js";import{s as K,d as Ie,a as xe}from"../chunks/BlVfL1ME.js";import{i as ue}from"../chunks/B4yTwGkE.js";import{a as E,c as Fe,b as oe,f as X}from"../chunks/CHOnp4oo.js";import{s as o,r as ge}from"../chunks/A7po6GxK.js";import{b as Ge,a as Pe}from"../chunks/sZcqyNBA.js";import{a as he}from"../chunks/554JRhq6.js";import{e as ke}from"../chunks/MAY1QfFZ.js";import{e as fe,i as ye}from"../chunks/CGEBXrjl.js";import{p as W}from"../chunks/V6gjw5Ec.js";import{N as Ce}from"../chunks/CcUbQ_Wl.js";const Re=.93,Te=.05,be="#8B95A5",Le="#818cf8",Oe=140,pe=8,De=4,Ke=12;function je(s){return!Number.isFinite(s)||s<=0?0:s*Re}function Ue(s){return Number.isFinite(s)?s>=Te:!1}function Ae(s){return!Number.isFinite(s)||stypeof b=="string");M.length!==0&&u.push({source_id:N.source_id,target_ids:M})}return u.reverse()}var Qe=oe(''),We=oe(''),Xe=oe(' '),Je=oe(''),Ze=oe('');function $e(s,f){Me(f,!0);let u=W(f,"width",3,900),x=W(f,"height",3,560),N=W(f,"source",3,null),M=W(f,"neighbours",19,()=>[]),b=W(f,"liveBurstKey",3,0),S=W(f,"liveBurst",3,null);const F=22,J=14;let B=A(le([])),G=A(le([])),T=A(le([])),U=0,O=null,ne=null,Z=0;function $(n,t,c,_){U+=1;const i=U,l=b()>0&&e(B).length>0?40:0,m=c+(Math.random()-.5)*l,g=_+(Math.random()-.5)*l;d(T,[...e(T),{burstId:i,x:m,y:g,radius:F,opacity:.75},{burstId:i,x:m,y:g,radius:F,opacity:.5}],!0);const V={id:`${n.id}::${i}`,label:n.label,nodeType:"source",x:m,y:g,activation:1,isSource:!0,sourceBurstId:i},H=[],k=[],C=U*.37%(Math.PI*2),re=qe(m,g,t.length,C);t.forEach((D,ie)=>{const se=re[ie];se&&(H.push({id:`${D.id}::${i}`,label:D.label,nodeType:D.nodeType,x:se.x,y:se.y,activation:Ye(ie,t.length),isSource:!1,sourceBurstId:i}),k.push({burstId:i,sourceNodeId:V.id,targetNodeId:`${D.id}::${i}`,drawProgress:0,staggerDelay:ze(ie),framesElapsed:0}))}),d(B,[...e(B),V,...H],!0),d(G,[...e(G),...k],!0)}function q(){let n=[];for(const i of e(B)){const l=je(i.activation);Ue(l)&&n.push({...i,activation:l})}d(B,n,!0);const t=new Set(n.map(i=>i.id));let c=[];for(const i of e(G)){if(!t.has(i.sourceNodeId)||!t.has(i.targetNodeId))continue;const l=i.framesElapsed+1;let m=i.drawProgress;l>=i.staggerDelay&&(m=Math.min(1,m+1/15)),c.push({...i,framesElapsed:l,drawProgress:m})}d(G,c,!0);let _=[];for(const i of e(T)){const l=i.radius+6,m=i.opacity*.96;m<.02||l>Math.max(u(),x())||_.push({...i,radius:l,opacity:m})}d(T,_,!0),O=requestAnimationFrame(q)}function Y(){d(B,[],!0),d(G,[],!0),d(T,[],!0)}ve(()=>{if(!N())return;const n=N().id;n!==ne&&(ne=n,Y(),$(N(),M(),u()/2,x()/2))}),ve(()=>{if(!S()||b()===0||b()===Z)return;Z=b();const n=(Math.random()-.5)*120,t=(Math.random()-.5)*120;$(S().source,S().neighbours,u()/2+n,x()/2+t)}),we(()=>{O=requestAnimationFrame(q)}),Ne(()=>{O!==null&&cancelAnimationFrame(O)});function ce(n,t){return Ve(n,t)}function ee(n){const t=e(B).find(l=>l.id===n.sourceNodeId),c=e(B).find(l=>l.id===n.targetNodeId);if(!t||!c)return null;const _=t.x+(c.x-t.x)*n.drawProgress,i=t.y+(c.y-t.y)*n.drawProgress;return{x1:t.x,y1:t.y,x2:_,y2:i}}var P=Ze(),te=y(p(P));fe(te,17,()=>e(T),ye,(n,t)=>{var c=Qe();L(()=>{o(c,"cx",e(t).x),o(c,"cy",e(t).y),o(c,"r",e(t).radius),o(c,"opacity",e(t).opacity)}),E(n,c)});var j=y(te);fe(j,17,()=>e(G),ye,(n,t)=>{const c=de(()=>ee(e(t)));var _=Fe(),i=Ee(_);{var l=m=>{var g=We();L(()=>{o(g,"x1",e(c).x1),o(g,"y1",e(c).y1),o(g,"x2",e(c).x2),o(g,"y2",e(c).y2),o(g,"opacity",.35*e(t).drawProgress)}),E(m,g)};ue(i,m=>{e(c)&&m(l)})}E(n,_)});var z=y(j);fe(z,17,()=>e(B),n=>n.id,(n,t)=>{const c=de(()=>ce(e(t).nodeType,e(t).isSource)),_=de(()=>e(t).isSource?F*(.7+.3*e(t).activation):J*(.5+.8*e(t).activation));var i=Je(),l=p(i),m=y(l),g=y(m),V=y(g);{var H=k=>{var C=Xe(),re=p(C,!0);v(C),L(D=>{o(C,"x",e(t).x),o(C,"y",e(t).y+e(_)+18),o(C,"opacity",.9*e(t).activation),K(re,D)},[()=>e(t).label.length>40?e(t).label.slice(0,40)+"…":e(t).label]),E(k,C)};ue(V,k=>{e(t).isSource&&e(t).label&&k(H)})}v(i),L(k=>{o(i,"opacity",k),o(l,"cx",e(t).x),o(l,"cy",e(t).y),o(l,"r",e(_)*1.9),o(l,"fill",e(c)),o(l,"opacity",.18*e(t).activation),o(m,"cx",e(t).x),o(m,"cy",e(t).y),o(m,"r",e(_)),o(m,"fill",e(c)),o(g,"cx",e(t).x-e(_)*.3),o(g,"cy",e(t).y-e(_)*.3),o(g,"r",e(_)*.35),o(g,"opacity",.35*e(t).activation)},[()=>Math.min(1,e(t).activation*1.25)]),E(n,i)}),v(P),L(()=>{o(P,"width",u()),o(P,"height",x()),o(P,"viewBox",`0 0 ${u()??""} ${x()??""}`)}),E(s,P),Se()}var et=X('
          ◎

          Computing activation...

          '),tt=X('
          ⚠

          Activation failed

          '),rt=X(`
          ◬

          No matching memory

          Nothing in the graph matches . Try a broader +import"../chunks/Bzak7iHL.js";import{o as we,a as Ne}from"../chunks/GG5zm9kr.js";import{p as Me,s as A,c as le,aB as ve,e as y,d as p,t as L,g as e,f as Ee,u as de,r as v,a as Se,h as d,n as me}from"../chunks/CpWkWWOo.js";import{s as K,d as Ie,a as xe}from"../chunks/BlVfL1ME.js";import{i as ue}from"../chunks/B4yTwGkE.js";import{a as E,c as Fe,b as oe,f as X}from"../chunks/CHOnp4oo.js";import{s as o,r as ge}from"../chunks/A7po6GxK.js";import{b as Ge,a as Pe}from"../chunks/sZcqyNBA.js";import{a as he}from"../chunks/B7CfdQuM.js";import{e as ke}from"../chunks/MAY1QfFZ.js";import{e as fe,i as ye}from"../chunks/CGEBXrjl.js";import{p as W}from"../chunks/V6gjw5Ec.js";import{N as Ce}from"../chunks/CcUbQ_Wl.js";const Re=.93,Te=.05,be="#8B95A5",Le="#818cf8",Oe=140,pe=8,De=4,Ke=12;function je(s){return!Number.isFinite(s)||s<=0?0:s*Re}function Ue(s){return Number.isFinite(s)?s>=Te:!1}function Ae(s){return!Number.isFinite(s)||stypeof b=="string");M.length!==0&&u.push({source_id:N.source_id,target_ids:M})}return u.reverse()}var Qe=oe(''),We=oe(''),Xe=oe(' '),Je=oe(''),Ze=oe('');function $e(s,f){Me(f,!0);let u=W(f,"width",3,900),x=W(f,"height",3,560),N=W(f,"source",3,null),M=W(f,"neighbours",19,()=>[]),b=W(f,"liveBurstKey",3,0),S=W(f,"liveBurst",3,null);const F=22,J=14;let B=A(le([])),G=A(le([])),T=A(le([])),U=0,O=null,ne=null,Z=0;function $(n,t,c,_){U+=1;const i=U,l=b()>0&&e(B).length>0?40:0,m=c+(Math.random()-.5)*l,g=_+(Math.random()-.5)*l;d(T,[...e(T),{burstId:i,x:m,y:g,radius:F,opacity:.75},{burstId:i,x:m,y:g,radius:F,opacity:.5}],!0);const V={id:`${n.id}::${i}`,label:n.label,nodeType:"source",x:m,y:g,activation:1,isSource:!0,sourceBurstId:i},H=[],k=[],C=U*.37%(Math.PI*2),re=qe(m,g,t.length,C);t.forEach((D,ie)=>{const se=re[ie];se&&(H.push({id:`${D.id}::${i}`,label:D.label,nodeType:D.nodeType,x:se.x,y:se.y,activation:Ye(ie,t.length),isSource:!1,sourceBurstId:i}),k.push({burstId:i,sourceNodeId:V.id,targetNodeId:`${D.id}::${i}`,drawProgress:0,staggerDelay:ze(ie),framesElapsed:0}))}),d(B,[...e(B),V,...H],!0),d(G,[...e(G),...k],!0)}function q(){let n=[];for(const i of e(B)){const l=je(i.activation);Ue(l)&&n.push({...i,activation:l})}d(B,n,!0);const t=new Set(n.map(i=>i.id));let c=[];for(const i of e(G)){if(!t.has(i.sourceNodeId)||!t.has(i.targetNodeId))continue;const l=i.framesElapsed+1;let m=i.drawProgress;l>=i.staggerDelay&&(m=Math.min(1,m+1/15)),c.push({...i,framesElapsed:l,drawProgress:m})}d(G,c,!0);let _=[];for(const i of e(T)){const l=i.radius+6,m=i.opacity*.96;m<.02||l>Math.max(u(),x())||_.push({...i,radius:l,opacity:m})}d(T,_,!0),O=requestAnimationFrame(q)}function Y(){d(B,[],!0),d(G,[],!0),d(T,[],!0)}ve(()=>{if(!N())return;const n=N().id;n!==ne&&(ne=n,Y(),$(N(),M(),u()/2,x()/2))}),ve(()=>{if(!S()||b()===0||b()===Z)return;Z=b();const n=(Math.random()-.5)*120,t=(Math.random()-.5)*120;$(S().source,S().neighbours,u()/2+n,x()/2+t)}),we(()=>{O=requestAnimationFrame(q)}),Ne(()=>{O!==null&&cancelAnimationFrame(O)});function ce(n,t){return Ve(n,t)}function ee(n){const t=e(B).find(l=>l.id===n.sourceNodeId),c=e(B).find(l=>l.id===n.targetNodeId);if(!t||!c)return null;const _=t.x+(c.x-t.x)*n.drawProgress,i=t.y+(c.y-t.y)*n.drawProgress;return{x1:t.x,y1:t.y,x2:_,y2:i}}var P=Ze(),te=y(p(P));fe(te,17,()=>e(T),ye,(n,t)=>{var c=Qe();L(()=>{o(c,"cx",e(t).x),o(c,"cy",e(t).y),o(c,"r",e(t).radius),o(c,"opacity",e(t).opacity)}),E(n,c)});var j=y(te);fe(j,17,()=>e(G),ye,(n,t)=>{const c=de(()=>ee(e(t)));var _=Fe(),i=Ee(_);{var l=m=>{var g=We();L(()=>{o(g,"x1",e(c).x1),o(g,"y1",e(c).y1),o(g,"x2",e(c).x2),o(g,"y2",e(c).y2),o(g,"opacity",.35*e(t).drawProgress)}),E(m,g)};ue(i,m=>{e(c)&&m(l)})}E(n,_)});var z=y(j);fe(z,17,()=>e(B),n=>n.id,(n,t)=>{const c=de(()=>ce(e(t).nodeType,e(t).isSource)),_=de(()=>e(t).isSource?F*(.7+.3*e(t).activation):J*(.5+.8*e(t).activation));var i=Je(),l=p(i),m=y(l),g=y(m),V=y(g);{var H=k=>{var C=Xe(),re=p(C,!0);v(C),L(D=>{o(C,"x",e(t).x),o(C,"y",e(t).y+e(_)+18),o(C,"opacity",.9*e(t).activation),K(re,D)},[()=>e(t).label.length>40?e(t).label.slice(0,40)+"…":e(t).label]),E(k,C)};ue(V,k=>{e(t).isSource&&e(t).label&&k(H)})}v(i),L(k=>{o(i,"opacity",k),o(l,"cx",e(t).x),o(l,"cy",e(t).y),o(l,"r",e(_)*1.9),o(l,"fill",e(c)),o(l,"opacity",.18*e(t).activation),o(m,"cx",e(t).x),o(m,"cy",e(t).y),o(m,"r",e(_)),o(m,"fill",e(c)),o(g,"cx",e(t).x-e(_)*.3),o(g,"cy",e(t).y-e(_)*.3),o(g,"r",e(_)*.35),o(g,"opacity",.35*e(t).activation)},[()=>Math.min(1,e(t).activation*1.25)]),E(n,i)}),v(P),L(()=>{o(P,"width",u()),o(P,"height",x()),o(P,"viewBox",`0 0 ${u()??""} ${x()??""}`)}),E(s,P),Se()}var et=X('

          ◎

          Computing activation...

          '),tt=X('
          ⚠

          Activation failed

          '),rt=X(`
          ◬

          No matching memory

          Nothing in the graph matches . Try a broader query or switch on live mode to watch the engine fire its own bursts.

          `),it=X(`
          ◎

          Waiting for activation

          Seed a burst with the search bar above, or enable live mode to overlay bursts from the cognitive engine as they happen.

          `),st=X('
          Seed

          '),at=X(`

          Spreading Activation

          Collins & Loftus 1975 — activation spreads from a seed memory to diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js.br b/apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js.br new file mode 100644 index 0000000000000000000000000000000000000000..48a22efb5df1a6e401bed6f822d6924c94975f1b GIT binary patch literal 4439 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 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js.gz b/apps/dashboard/build/_app/immutable/nodes/4.DYVet_v-.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..7edd3c0a04d27cae3e389c57ac4b3e2fad04e196 GIT binary patch literal 4975 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 literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js b/apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js similarity index 99% rename from apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js rename to apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js index 8d4e000..77162f8 100644 --- a/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js +++ b/apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js @@ -1,4 +1,4 @@ -import"../chunks/Bzak7iHL.js";import{p as qe,d as a,r as t,e as i,g as e,f as he,u as b,t as R,a as Se,n as X,h as de,s as be,W as Ge,aG as Ae}from"../chunks/CpWkWWOo.js";import{s as x,d as Ye,a as pe}from"../chunks/BlVfL1ME.js";import{c as Fe,a as m,f as _,b as Ve,t as Ie}from"../chunks/CHOnp4oo.js";import{i as j}from"../chunks/B4yTwGkE.js";import{e as ge}from"../chunks/CGEBXrjl.js";import{h as We}from"../chunks/C4h_mRt2.js";import{s as A,r as Be,a as Xe}from"../chunks/A7po6GxK.js";import{s as _e}from"../chunks/aVbAZ-t7.js";import{a as ze}from"../chunks/554JRhq6.js";import{s as ae}from"../chunks/Cx-f-Pzo.js";import{p as Ue}from"../chunks/V6gjw5Ec.js";import{b as Je}from"../chunks/DGcYlAAw.js";const Te=5,je=["Replay","Cross-reference","Strengthen","Prune","Transfer"];function Oe(v){if(!Number.isFinite(v))return 1;const n=Math.floor(v);return n<1?1:n>Te?Te:n}const Ke=.3,Qe=.7;function Ze(v){const n=ye(v);return n>Qe?"high":n1?1:v}function $e(v){return v==null||!Number.isFinite(v)||v<0?"0ms":v<1e3?`${Math.round(v)}ms`:`${(v/1e3).toFixed(2)}s`}function et(v){const n=ye(v);return`${Math.round(n*100)}%`}function tt(v,n=""){return`${n}/memories/${v}`}function st(v,n=2){return!v||v.length===0?[]:v.slice(0,Math.max(0,n))}function at(v,n=2){return v?Math.max(0,v.length-n):0}function rt(v){return v?v.length>8?v.slice(0,8):v:""}var nt=_('

          Episodic hippocampus
          Semantic cortex
          ',1),it=Ve(''),vt=_('
          '),lt=_(''),ot=_('Replaying memories'),ct=_('New connections found: '),dt=_('Strengthened: '),ut=_('Compressed: '),ft=_('Connections persisted: Insights: ',1),mt=_('
          ');function pt(v,n){qe(n,!0);const N=[{num:1,name:"Replay",color:"#818cf8",desc:"Hippocampal replay: tagged memories surface for consolidation."},{num:2,name:"Cross-reference",color:"#a855f7",desc:"Semantic proximity check — new edges discovered across memories."},{num:3,name:"Strengthen",color:"#c084fc",desc:"Co-activated memories strengthen; FSRS stability grows."},{num:4,name:"Prune",color:"#ef4444",desc:"Low-retention redundant memories compressed or released."},{num:5,name:"Transfer",color:"#10b981",desc:"Episodic → semantic consolidation (hippocampus → cortex)."}];let l=b(()=>Oe(n.stage)),f=b(()=>N[e(l)-1]),q=b(()=>{if(!n.dreamResult)return 8;const s=n.dreamResult.memoriesReplayed??8;return Math.max(6,Math.min(12,s))}),re=b(()=>{var r;if(!n.dreamResult)return 5;const s=((r=n.dreamResult.stats)==null?void 0:r.newConnectionsFound)??5;return Math.max(3,Math.min(e(q),s))}),z=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.5);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesStrengthened)??Math.ceil(e(q)*.5);return Math.max(1,Math.min(e(q),s))}),ne=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.25);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesCompressed)??Math.ceil(e(q)*.25);return Math.max(1,Math.min(Math.floor(e(q)/2),s))});function C(s,r=0){const d=Math.sin((s+1)*9301+49297+r*233)*233280;return d-Math.floor(d)}let U=b(()=>{const s=[],r=Math.ceil(Math.sqrt(e(q))),d=Math.ceil(e(q)/r);for(let c=0;c{const s=[],r=e(U).length;for(let d=0;d{var r=nt();X(4),m(s,r)};j(le,s=>{e(l)===5&&s(oe)})}var ee=i(le,2);ge(ee,23,()=>e(L),(s,r)=>s.a+"-"+s.b+"-"+r,(s,r,d)=>{const c=b(()=>e(U)[e(r).a]),p=b(()=>e(U)[e(r).b]);var u=Fe(),k=he(u);{var w=g=>{const M=b(()=>I(e(c))),h=b(()=>F(e(c))),V=b(()=>I(e(p))),ke=b(()=>F(e(p)));var E=it();R(()=>{A(E,"x1",e(M)),A(E,"y1",e(h)),A(E,"x2",e(V)),A(E,"y2",e(ke)),A(E,"stroke",e(f).color),A(E,"stroke-width",e(l)===2?.25:e(l)===3?.35:.2),A(E,"stroke-opacity",e(l)<2?0:e(l)===4?.25:e(l)===5?.15:.6),A(E,"stroke-dasharray",e(l)===2?"1.2 0.8":"none"),ae(E,`--edge-delay: ${e(d)*80}ms`)}),m(g,E)};j(k,g=>{e(c)&&e(p)&&g(w)})}m(s,u)}),t(ee);var S=i(ee,2);ge(S,17,()=>e(U),s=>s.id,(s,r)=>{var d=vt();let c;R((p,u,k,w,g)=>{c=_e(d,1,"memory-card svelte-1cq1ntk",null,c,{"is-pulsing":e(l)===3&&e(r).strengthened,"is-pruning":e(l)===4&&e(r).pruned,"is-transferring":e(l)===5,"semantic-side":e(l)===5&&e(r).transferIsSemantic}),ae(d,` +import"../chunks/Bzak7iHL.js";import{p as qe,d as a,r as t,e as i,g as e,f as he,u as b,t as R,a as Se,n as X,h as de,s as be,W as Ge,aG as Ae}from"../chunks/CpWkWWOo.js";import{s as x,d as Ye,a as pe}from"../chunks/BlVfL1ME.js";import{c as Fe,a as m,f as _,b as Ve,t as Ie}from"../chunks/CHOnp4oo.js";import{i as j}from"../chunks/B4yTwGkE.js";import{e as ge}from"../chunks/CGEBXrjl.js";import{h as We}from"../chunks/C4h_mRt2.js";import{s as A,r as Be,a as Xe}from"../chunks/A7po6GxK.js";import{s as _e}from"../chunks/aVbAZ-t7.js";import{a as ze}from"../chunks/B7CfdQuM.js";import{s as ae}from"../chunks/Cx-f-Pzo.js";import{p as Ue}from"../chunks/V6gjw5Ec.js";import{b as Je}from"../chunks/D8UfWY0j.js";const Te=5,je=["Replay","Cross-reference","Strengthen","Prune","Transfer"];function Oe(v){if(!Number.isFinite(v))return 1;const n=Math.floor(v);return n<1?1:n>Te?Te:n}const Ke=.3,Qe=.7;function Ze(v){const n=ye(v);return n>Qe?"high":n1?1:v}function $e(v){return v==null||!Number.isFinite(v)||v<0?"0ms":v<1e3?`${Math.round(v)}ms`:`${(v/1e3).toFixed(2)}s`}function et(v){const n=ye(v);return`${Math.round(n*100)}%`}function tt(v,n=""){return`${n}/memories/${v}`}function st(v,n=2){return!v||v.length===0?[]:v.slice(0,Math.max(0,n))}function at(v,n=2){return v?Math.max(0,v.length-n):0}function rt(v){return v?v.length>8?v.slice(0,8):v:""}var nt=_('
          Episodic hippocampus
          Semantic cortex
          ',1),it=Ve(''),vt=_('
          '),lt=_(''),ot=_('Replaying memories'),ct=_('New connections found: '),dt=_('Strengthened: '),ut=_('Compressed: '),ft=_('Connections persisted: Insights: ',1),mt=_('
          ');function pt(v,n){qe(n,!0);const N=[{num:1,name:"Replay",color:"#818cf8",desc:"Hippocampal replay: tagged memories surface for consolidation."},{num:2,name:"Cross-reference",color:"#a855f7",desc:"Semantic proximity check — new edges discovered across memories."},{num:3,name:"Strengthen",color:"#c084fc",desc:"Co-activated memories strengthen; FSRS stability grows."},{num:4,name:"Prune",color:"#ef4444",desc:"Low-retention redundant memories compressed or released."},{num:5,name:"Transfer",color:"#10b981",desc:"Episodic → semantic consolidation (hippocampus → cortex)."}];let l=b(()=>Oe(n.stage)),f=b(()=>N[e(l)-1]),q=b(()=>{if(!n.dreamResult)return 8;const s=n.dreamResult.memoriesReplayed??8;return Math.max(6,Math.min(12,s))}),re=b(()=>{var r;if(!n.dreamResult)return 5;const s=((r=n.dreamResult.stats)==null?void 0:r.newConnectionsFound)??5;return Math.max(3,Math.min(e(q),s))}),z=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.5);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesStrengthened)??Math.ceil(e(q)*.5);return Math.max(1,Math.min(e(q),s))}),ne=b(()=>{var r;if(!n.dreamResult)return Math.ceil(e(q)*.25);const s=((r=n.dreamResult.stats)==null?void 0:r.memoriesCompressed)??Math.ceil(e(q)*.25);return Math.max(1,Math.min(Math.floor(e(q)/2),s))});function C(s,r=0){const d=Math.sin((s+1)*9301+49297+r*233)*233280;return d-Math.floor(d)}let U=b(()=>{const s=[],r=Math.ceil(Math.sqrt(e(q))),d=Math.ceil(e(q)/r);for(let c=0;c{const s=[],r=e(U).length;for(let d=0;d{var r=nt();X(4),m(s,r)};j(le,s=>{e(l)===5&&s(oe)})}var ee=i(le,2);ge(ee,23,()=>e(L),(s,r)=>s.a+"-"+s.b+"-"+r,(s,r,d)=>{const c=b(()=>e(U)[e(r).a]),p=b(()=>e(U)[e(r).b]);var u=Fe(),k=he(u);{var w=g=>{const M=b(()=>I(e(c))),h=b(()=>F(e(c))),V=b(()=>I(e(p))),ke=b(()=>F(e(p)));var E=it();R(()=>{A(E,"x1",e(M)),A(E,"y1",e(h)),A(E,"x2",e(V)),A(E,"y2",e(ke)),A(E,"stroke",e(f).color),A(E,"stroke-width",e(l)===2?.25:e(l)===3?.35:.2),A(E,"stroke-opacity",e(l)<2?0:e(l)===4?.25:e(l)===5?.15:.6),A(E,"stroke-dasharray",e(l)===2?"1.2 0.8":"none"),ae(E,`--edge-delay: ${e(d)*80}ms`)}),m(g,E)};j(k,g=>{e(c)&&e(p)&&g(w)})}m(s,u)}),t(ee);var S=i(ee,2);ge(S,17,()=>e(U),s=>s.id,(s,r)=>{var d=vt();let c;R((p,u,k,w,g)=>{c=_e(d,1,"memory-card svelte-1cq1ntk",null,c,{"is-pulsing":e(l)===3&&e(r).strengthened,"is-pruning":e(l)===4&&e(r).pruned,"is-transferring":e(l)===5,"semantic-side":e(l)===5&&e(r).transferIsSemantic}),ae(d,` left: ${p??""}%; top: ${u??""}%; opacity: ${k??""}; diff --git a/apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js.br b/apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js.br new file mode 100644 index 0000000000000000000000000000000000000000..0dc56f06fbcc54e4cf5c8f4de515303ebfbe198e GIT binary patch literal 5620 zcmVutv>;k~qNM&!xSmDFbnzrY+9vN zCG|38o8fVgNV4ZH<{+QY7g_ZStm-bw>XrstG&?dZpzH-MXnUl#Z%1BWjt8P6$nu5g z-lfS+wz}1@+q?rQLZ;F`U&hk!Hfg)FI}{QwV|WDX?`N6#FH76_h)()Yr_;f`Ro{9a zSB?FJOg@hAmp`)>;(^A$rR>o&>X|58JOmV5fK$r>jIa29(s^tyF)$=h_eMDyt||E;GFmkp<9^Vcek$CmuwJx`bRrxu`VEd_yf2H4usBFzKysf+4_MQ=5`8daE zYsVk2$B5XK7e6!F`R#I*ud&oRfR!blY?;Z(>x6~ zVXZfiOKDXZ*+5zJGKwAQW9k?0r4YSnh!YLCPsh1_HZp7=N^Xf738u zxL0*6IKGG01|pVJWPhcD=_ z7Q^nQ-P5i+>Jhd+lQp{RKFxkXS$}=r%qP%iw>ia>ZR4wW#?!zAc$gzE5P)8@C+L0c zSA?euN2V)%o{s^T6{ABFS}n1}fhfB_-Cmyyt~qx3#{cikE)fs{e<ADTozZB20UnwDVq2~xup2DjxGcNA*+#@eo6eZi9zkOnryo3t9(<2S%> z(Kh@JO>>Xl;tx>lr%v1aUgNU^B6R$p@12wm&2W(RzXH3Ijz!+}4ek0D3O!^?hL}ZL zWj7(J;rJItcc73SRa};dTcl-8!4(I<9olGW?k57mz~BPacMB0EKDU>=_$TXfl3&* zshm}1-P&>OHhD<`YUR36>$2OvW|LLKyb~ao-n8NE&hc0ODqr}Y38U@xESrcM#kG4d ztQ(d5;Xr{^N9ix}aK7QIQ*@o%LK&Xbp`!E_pEvaqlMx#(Lr)L6`gfe@A5iRyh6cb9 z)_Hr2ht>eL!yBdn!tVs~FDo-WH{NjX6k^ieD6iD0?zRy!+@_}Nb%w{X0)I*tb-XeB%>vn2TiLf zCHVdjTIp5WsQ5;j#kV1&bek@VYPxuyle4v_Hf6D4f_{n?=(z=XRZSuQ0A!?^jjBNEPtoF2 z1LM{ohOoV|>b|$5R?=K{^oYyD@th$1aF1`?8=E!Sh^)vzQy-(T^-*_5e`fGx#JIx+ zozU$3FMj}hF;EN$(;mRo7&7qALkTCTwb&D!!D?y#A63N&AnTXn^47#pMtQOX%M!oz z{a83pF zIG*Tr;uNN-p~0shk@)uE69ibfk*kNUg-wv*^T`v<&< zK`!=!5plVfk92cU7MCW5t1*hAP%P*_gKg(MpM=OhXwYkjPV^L-jqfg=z*V*_J30om zAoB!cj29DFf+tXR+;=GKF0v%#R4!kf0O$S_o?n}dH?JyB6^#JqVlcTi3s1H8cs#9o zgXR+a_*NW+(KJoyRM98+PZ!+~VL+}9C3-*6?R?z_eB{^!r))VPIzOxP^Fn9p)V7q& zGc0bZ=3hl$EWJXD3rfRV8X!bKW`-pxt)jf80M?D^l~uJ4s37<|JZ#jc#tdu8Lvfem z3|}ta1tY?XcCjFhb+zojrYHY72%2f>8f0n7^j0)+Nld)an%SD7_ByBs2s4hSze0#EPafPkJ$a@>5hPb3dFPO=6QE_{n(d>9SD)iTa7Gqbs*Xz#2g=n<*uJ(>_WIaKF zdPp%wWB%)Wb}*khssc6cQ+(DRC5Ij=G1m!;=B^3z`AvH0Yh%3nMrMBdn0;;X_BWYXU$`EEv z;^xqbXbqXh(iY+Ptm!35aIf{%x#sgp3L&d1*X3MVTpm~7;RBSOh6>zi9^y26VmXj)XA!3GYHGzWW+jD7UK8 zRCO|2>zUJ|y$5l{E@v3!2~|SM(?!<-At6s|UK$(>94;@O8RF`~sheDfS#r@WDG>|u zX0L}^v7n0xwyaWMgMDN~rxSTsLd@Mx%S^c`2hsRe17(f_F13=Q40iAY;$Ez~k)N_* zKa&~#>&cudF)yIp3otw_A~=hd+7x3aLVu+3(9Y6qN=wU6#m!}ywC@ajAH@QEARzk~ zel+dXjTqXt>va$^OY+sKK7zK!y(=cXk4M^4FaRtI=CioLJJ&zr%!SxBAiXq)bXWM{ zS8medf{!!6#yN5?NAc)Dw;*Ecl> zbWgs1md(!+>^zkMGH6P+`v==#CfFtEeuw%X>aEq=P_c|d&gwWTRPOxqPHa*GabKiS6>eZzRj=S2U-c#vW;fq1y>Hof@YUij_4ZR=pXqj^x0?E{eo!KkVdxL%VYSvdc$Rxe z6b=W5(F&IiN^vcTYa&>eh{eqa4aKD~Dtz+I1bJ-Eo2K1#p`Io=oZh;^37~|g^zM>} z6u~)gXTCA-LwDK8qkgrY=}fB7UF%7!d;MjjnHM;9p4@0DP0y$QPhN=MdG4^p7mXGtWM`iGXMv6gX+}GfcsV|$3(-B(Fm#jpp z=S_&V*Ihv_j-!GaZmZv`t?hRGo>82OT0$a98Om!L3Qro*h?@4DQ0dSXr9*F22OpnL zGX#%tF|~>N)Z5ub#?Gt-{2N_Y*syIYe2fq7XW*(Ke~U%scc|28-#KlGA2ugf#G_%f<9vfTjA>A4bZ0bN z8uAW!9zt2N*I=8Shx|K{i@7`ag)HP@p z1`ojiY$D#$G2wsnI&uTs$+~%HY3>g&?|fg@!k4_7*sTSc zJ?lWb8>}cFx|POF;fbMZ=E7NpRhzDD^EV#?brH{wlj%La5yoz2R?8ZdqJ)gMi!`bz zrDR=pr#EK8JleetMRbcH?SfOKPG*~R7;WmFY$SIhGSI_sVl|JUx@1%!Wj=?}Lst8C zn~`0VEP-544v3a#E|k5ihc8t>%c=&dF> zpJS%1eNMEVbcjBfY6(MYvtY}i0rnRWGJ^ew*}iU*&(fTV`OFM&LQj zc2Kx>y1bQXtY$xaC!u9Vp;G9_R;A$j9g4!FkzSP-@6>Z+4}`+%}#J;FjK-#@^Q zwx&?Ln|R0}<#2A=Bqm7AGZbStHGxeFQW?LDZ>)#PHxJ~EQuG@^ahxR6(O9|AG=;Fd zp!K){$|N1~kQQDW&T^6*Yz(_AbqGgXb(pX~Zavwx@WMGK$UV3G;2tg{Nk8(Gb4UTt zlu`lDr9S29KKmc45T$ZY+;sQUd`l$4L+$V9rYqb&DuMx(K1D$uqhOjiu3*7Q@-V1& z!`xspfu;0{N~~A72DNDi^HHT*o79P*cN>(5!Pc#&?}AC71Y^_7QrU=<9VcOZ20HY< zSql-RGK?n$dJB|4X>6_0%ut5tgYkr>bT;#nL{!r`x|l;SMH>J$-b52 z$S}@vWQ2!gd(x<6L_I(qS>CH4Cyua2k69Gby}r1O=D5jGGk~2n)}Pm~=+W00vT+h< z2BE!HO?*--F0&n@vDbD9KG3#Z0H3p@?J20p@3p!mwV;g(T|yFX`zC6-RP_Qhx{mqR zRJ@{b`TDd%TdSNX>?ELD;gxFdGxA9EBuz1-Cm0S7zq&_*=-GEd)pCmCHp8)4PQpW(b5ah+y7V%ReBAyf5l&aSK6Pc|udY+W zoEobQQr;vTYO#SL6Na2{71+O_iWUaM;F-TalN*}4rHNxYM}pPLZ|L^UQ*z@Hl5@Kc Ol-O)e?w~0BpWXo-ogZKT literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js.gz b/apps/dashboard/build/_app/immutable/nodes/6.54m-BxV_.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..9a8e1e669443783fb9d2c2cf858079039e6f6b5f GIT binary patch literal 6334 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 Tei4@4?gJ$bo0mH%O7H9)Sm*+? diff --git a/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.gz b/apps/dashboard/build/_app/immutable/nodes/6.BD0AetaD.js.gz deleted file mode 100644 index b1295da2122839f763decab437564110920843bc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6335 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 BOIrW{ diff --git a/apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.br b/apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js.br deleted file mode 100644 index 87e1326543b67dbb29444ac8c2387906b9d2e1ba..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3017 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 N?tkeSwP?~M005}3wtoNs diff --git a/apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js b/apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js similarity index 99% rename from apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js rename to apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js index 33dba0f..d57b207 100644 --- a/apps/dashboard/build/_app/immutable/nodes/8.CokrlgDp.js +++ b/apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js @@ -1,4 +1,4 @@ -import"../chunks/Bzak7iHL.js";import{p as ze,s as I,c as Ae,g as e,a as Pe,d as r,e as a,h as b,r as t,i as Qe,t as y,f as ge,u as se,j as qe}from"../chunks/CpWkWWOo.js";import{d as Be,a as q,s as o}from"../chunks/BlVfL1ME.js";import{a as c,f as m,c as De}from"../chunks/CHOnp4oo.js";import{i as k}from"../chunks/B4yTwGkE.js";import{e as ie,i as ne}from"../chunks/CGEBXrjl.js";import{r as ye}from"../chunks/A7po6GxK.js";import{s as oe}from"../chunks/aVbAZ-t7.js";import{s as Ke}from"../chunks/Cx-f-Pzo.js";import{b as de}from"../chunks/sZcqyNBA.js";import{a as X}from"../chunks/554JRhq6.js";var Re=m(''),Ue=m('
          Source

          '),Ve=m('
          Target

          '),Ge=m(`
          Target Memory
          '),Ue=m('
          Source

          '),Ve=m('
          Target

          '),Ge=m(`
          Target Memory
          `,1),He=m('
          ◎

          '),Je=m(' '),Le=m(" "),We=m(" "),Xe=m(" "),Ye=m(' '),Ze=m('

          '),et=m('

          '),tt=m('
          ◬

          No connections found for this query.

          '),rt=m('
          '),at=m('
          '),st=m('
          '),it=m(`

          Explore Connections

          Source Memory

          Importance Scorer

          4-channel neuroscience scoring: novelty, arousal, reward, attention

          `);function ft(he,we){ze(we,!0);let V=I(""),G=I(""),F=I(null),C=I(null),B=I(Ae([])),$=I("associations"),O=I(!1),H=I(""),D=I(null);const le={associations:{icon:"◎",desc:"Spreading activation — find related memories via graph traversal"},chains:{icon:"⟿",desc:"Build reasoning path from source to target memory"},bridges:{icon:"⬡",desc:"Find connecting memories between two concepts"}};async function ve(){if(e(V).trim()){b(O,!0);try{const s=await X.search(e(V),1);s.results.length>0&&(b(F,s.results[0],!0),await Y())}catch{}finally{b(O,!1)}}}async function pe(){if(e(G).trim()){b(O,!0);try{const s=await X.search(e(G),1);s.results.length>0&&(b(C,s.results[0],!0),e(F)&&await Y())}catch{}finally{b(O,!1)}}}async function Y(){if(e(F)){b(O,!0);try{const s=(e($)==="chains"||e($)==="bridges")&&e(C)?e(C).id:void 0,i=await X.explore(e(F).id,e($),s);b(B,i.results||i.nodes||i.chain||i.bridges||[],!0)}catch{b(B,[],!0)}finally{b(O,!1)}}}async function ke(){e(H).trim()&&b(D,await X.importance(e(H)),!0)}function Se(s){b($,s,!0),e(F)&&Y()}var Z=it(),ee=a(r(Z),2);ie(ee,20,()=>["associations","chains","bridges"],ne,(s,i)=>{var d=Re(),_=r(d),h=r(_,!0);t(_);var f=a(_,2),p=r(f,!0);t(f);var n=a(f,2),g=r(n,!0);t(n),t(d),y(w=>{oe(d,1,`flex flex-col items-center gap-1 p-3 rounded-xl text-sm transition diff --git a/apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js.br b/apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js.br new file mode 100644 index 0000000000000000000000000000000000000000..94fe0cd3cf28f4bec210c7bcd35f575f282e2131 GIT binary patch literal 3012 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 GJ@{`HYSM%N literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js.gz b/apps/dashboard/build/_app/immutable/nodes/8.DGKslLJe.js.gz new file mode 100644 index 0000000000000000000000000000000000000000..57e055d17a0df59a3cd1f3b0ee6bfb9697be84d4 GIT binary patch literal 3485 zcmV;O4Px>iiwFP!000026U|!NZrex_ect&BhRArxou(|=&SYRk4s1tu65k`oPHY%9 zMYhD2DUuaIFnb*j3W3F}8; z%=JoT+40igHd)@fw{M@b*ZY-TqSu*_K170tME!i3m5qjI;wtn%IF z)`z&~mzN0tjAo{8K99nmc87cAsdB3`Q|+_%=7q(d&rIE$1u(Qa*75zs?%Fujotc_k zIG;v`TbnZ;{4nE)=i43kBs~x_@9bE6M;m?PhZpUX^Dx+WkwkW&Ili4F4V}{=w}!sH zp}knf=P;JVoiN~5pSmpVFPb7WT-K`5@JbWk`zfcc{OZtv)3{jqVp(DM!6fe`D3{%3 znj&je>*7}}4%5J;E&$V>w8Pk?v6YMhJ4)#CN>$$|FPbs0CR$xT9BBQvRnyWaqOoHq zRO7Mj+_Io+4Va6#T45SH^u;ph1B}sx&ZIB(;fL5k1Ro{C9iI-ht{qt`TAy3B$}?@g zCv@rXDeskBg2v@1c;)QdyyC{x?tj@QV%k@Ea|@WEVYhQ?>)M9BPfMRec_p z6SZa5*CyC2ccvZCei)DDP*_1LP$*DyHwczl5T#t>qliicx)%9>%L{#QWJ7OJJ9a#P z5Nq56KTGR(bt#3 zJ2Ibhu1@YEW9QTk3guJW%ve_1mlxgv@?6(y8IiuR!vZ(2DP`VhFP?1NkeW$e&*W37 zFd@{RbGppQAs-IZfc0%ottj;&T_AfP_P_n>A9;qzJjmJlR@y7G3!H+v0Jf^r!Ckw` z_F51Rlf?mfi^ZkKO42s>X*n<=7hoTK5CXZm$cxn? zUK0#1$E<8%VEv?d@Hf-jNqrwZlym&qoSL4cc?p3EXD>}S>x{CWBDE4PX2Gph#gYX6 z*K>kQT`!sxmFIFDo-rB{!Pmw`UyMjhU          nS zWW%YNkUz1-uvKTFfs3fxDc%bHx=!PFHX50YKiX;(*MkL{$l8tBqhvwDkuCg|mZSJv zCNhU|r_k_O-_Dj}=sFe>S!LlHasRUe;8M$hV8^0HPdDsSm8FejU9%j|h7|DOI-JH~ z;xLL@63_zIfORc^{rh}GG#i|f*gnx>I{t+=?+Gk zq(~?Z6!56?lDX*rOU6H4k@&dt?7k(mpK8Pf#Hdzq1cn5002%qcT;h1$DPq~2fB z91CLPRGn@tZp?Zo4MZW-I^6Im8Bp`#o*Dy6o>a}c54V-G#v4P2R&rO3J1_3Ef`tiuVOKtDwr59KB64-5qBI`r5& zacSbL>#Yd3=K?!58}QzVdD?Hk{8Q^dEF2PxSG)ZUea-Ef2*VHOvRrF{p87R(Q<%hG{;ujUy2g9*-WR*OG=kuo>4r zR1$Fri1~2esV5a6cIxw_;?tnZy^ZS9lF>GHNG`anUZFA~6?_E!W5?!>_b>)`+P*)M z=4$46Je~p<<=}R|5!~+Qz-`ZhqsET8wDdb5e#{W=EPw{0r)Hzk&?O=C$H(k}3aSo< zsj+Ro#E%Md*Y84T3aW(VyHW?NFai?@DjpsydoL2qQn|F$CNs=wJmBS=#{4=DR~)OHpaJv7Y)V@ zct{(z5gQjKSuyJj^iZ-=C5GA9xSY&wlDUxNuDc=uB}PIR%zi+fZsQ%`CD)DEa82UD za4jQZT$|$6WCx60gC!DytfOQdDGNZ>L0K1MfszGqyFgtdV*oZnYPh6EZi-tMG;Xua zD|9_@rc56dcuTRfu}{9$(&V+X*=KM^;IE2EneGS0?#n=nnk4 zg<2%y1>t5u0S5x&nq%}ErP8w;V~l|XsSG!#7;o|xJng`w5jEb*sXHiti(KF+0VP~1 z8KQ)vlDdfXDQzSw?5yz~!|n>zOlTGqP%(6+0uRJ4$~qwPzJdaI{5||&NCIO(?vZRE zuxKFNDAE#B?-Uwm>C&605BD!$>iYP5DDH2%EDuS`YhSY_)TuDDOb6meQhLoTuWO^mWDFyF~6zikQhK0+XmR+_hUDm~@6&Zsb zyf!l*)z#ir_C#6s1R#w>*a9i(f+Ubpi)6-##{=bZY5u;ED(lV08Co9-b4?MjJy1DR z(HP3r2Z$bJEs!0UWD|y#n$nU}PGL$5ryPUq6a}Yf{s2FkB48(^Cj+)ePB1!~L=@U` zz>YCsz0U+}`||(iH#Zv9yGzB?J^gLL_Q91Yus=*d?i1&ekr$Z5Q{DO6-#2>qexcLE|+_yCV95i2eY=*TwL4F>-;3obbnh+{mjmb~h!b zKudokicLfU2$WY+PPvgKu+mHJVHlwL0jlpx?xbM9t4^Jitkjg-woGxVG|7LFQ6(ZoSBWwrPPh zUxGk;InZqc+AfmusEqXEmuXeJ-<%=WcFFqWG=y*@AaI~FWY(rCzM1mlTseXkTASoR zHV5fcrr)F6F#S}wE*w~Xf2QqVLsicDPATg-WPM!;0JKXYf%(XM8NuBFl#URHIS2T)Qv~EtR!4a+ zU=3)eWVv}|R@57k1Pi8mo|6Q{A#~Z$HBzj|<=-MdA0MlxG=AMku=0tn_v@RSa-ZuJ zr?xlu)V9&dP%fKUxjbt3AUYKYF5Wr~*#TntoG6}ZQ=jmbu!r?t-uGJ#>4F0j?_rz8 zuiBM5++*C3Jle?#495!Xu>{%!pvSnAeUSA~(366!-VrEuF%%iO>K*R!6d89eI)W3@ z!Xp!!`h9HbJ^5y6;stxruv>6X(%du_w-M`EwW|KbQ?~J-2v17&HcNl07jN|RbtP19 zxTH|LLdiw)otKov)B#h_W!g38H6pBNM6lTd52eCG5ws5Ip8)+64e_1Q2yQo-i?TO|!$cg-uDMb9 zsk8@t+a%=j=hT}gHD|Rdw>t5!l=+Qj>OGve@8JJGkawCc$&I!)&zhj9wfE*&FB&&@ z#t#X(7CS%4()^W3^Fvj|uEmw(VzS?Qi&K;7e(Nslx8AD8;mpK&ZQ~3s=jDEDhmt!g zW)-tk LtHv20(j@=@;XlFE literal 0 HcmV?d00001 diff --git a/apps/dashboard/build/_app/version.json b/apps/dashboard/build/_app/version.json index a0b8a69..d87c2dc 100644 --- a/apps/dashboard/build/_app/version.json +++ b/apps/dashboard/build/_app/version.json @@ -1 +1 @@ -{"version":"2.1.22"} \ No newline at end of file +{"version":"2.1.23"} \ No newline at end of file diff --git a/apps/dashboard/build/_app/version.json.br b/apps/dashboard/build/_app/version.json.br index 7ee1248..94cb2d3 100644 --- a/apps/dashboard/build/_app/version.json.br +++ b/apps/dashboard/build/_app/version.json.br @@ -1 +1 @@ - {"version":"2.1.22"} \ No newline at end of file + {"version":"2.1.23"} \ No newline at end of file diff --git a/apps/dashboard/build/_app/version.json.gz b/apps/dashboard/build/_app/version.json.gz index 9667dd0a5c88d811afedca6ce9dd19bac860a992..f6da5732e268147b5b1f521bb6b8796d6272b2c0 100644 GIT binary patch delta 17 YcmdPUm>|Owwu+VE!(x#V5e5bZ04i1lJpcdz delta 17 YcmdPUm>|Oww2GDC_{nRfA`A=+04{k1`2YX_ diff --git a/apps/dashboard/build/index.html b/apps/dashboard/build/index.html index ce5c054..4d5765f 100644 --- a/apps/dashboard/build/index.html +++ b/apps/dashboard/build/index.html @@ -11,13 +11,13 @@ - - + + - + - + @@ -33,7 +33,7 @@

          @BK2%`^?Oi!^QVGwawl# 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%0D`G<+Pc0p{0IP(m|{ptokisOitK9>gKBvWrP*P# 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