agentmux_srv/

persist.rs

// Copyright 2026, AgentMux Corp.
// SPDX-License-Identifier: Apache-2.0
//
// Phase E.2 — bootstrap helper: load SQLite-persistent state into
// the srv reducer at startup. The reducer's state is a SESSION-only
// projection in E.2/E.2b — it's populated from SQLite at boot,
// mutated by pipe-originated commands during the session, and
// discarded on restart (the next bootstrap re-reads SQLite).
//
// HTTP/WS RPC continues to write to SQLite directly via wcore. So
// SQLite stays authoritative for the duration of the session even
// though the reducer's view diverges as soon as a pipe command
// runs. That's intentional: pipe-originated commands have no
// client populating them yet (saga coordinator is empty in E.1a;
// E.5+ adds saga consumers). Once those exist, E.2c adds the
// persist subscriber that mirrors pipe-event effects back to SQLite.
//
// This module DOES NOT define a persist subscriber. The HWM /
// broadcast-lag concerns codex flagged are deferred to E.2c when
// the subscriber actually exists.

use std::sync::Arc;

use tokio::sync::Mutex;

use crate::backend::obj::{Block, Tab, Window, Workspace};
use crate::backend::storage::wstore::WaveStore;
use crate::state::{BlockRecord, State, TabRecord, WindowRecord, WorkspaceRecord};

/// Phase E.2 / E.2b — load workspaces and their tabs from SQLite
/// into the reducer state. Called once at srv startup before the
/// IPC server starts accepting commands. Async because we're inside
/// the tokio runtime.
///
/// Errors are logged but non-fatal: if a SQLite read fails (fresh
/// install, empty DB, transient I/O), the reducer starts with
/// whatever loaded successfully. Workspace and tab loads are
/// independent — a workspace-load failure does not prevent the tab
/// load from being attempted (and vice versa), since pipe commands
/// later in the session can populate either map.
pub async fn bootstrap_state_from_wstore(state: &Arc<Mutex<State>>, wstore: &WaveStore) {
    let workspaces = wstore.get_all::<Workspace>().unwrap_or_else(|e| {
        tracing::warn!(
            target: "srv-persist",
            "[srv-persist] bootstrap: failed to load workspaces from wstore: {} — workspaces start empty",
            e
        );
        Vec::new()
    });
    let tabs = wstore.get_all::<Tab>().unwrap_or_else(|e| {
        tracing::warn!(
            target: "srv-persist",
            "[srv-persist] bootstrap: failed to load tabs from wstore: {} — tabs start empty",
            e
        );
        Vec::new()
    });
    let blocks = wstore.get_all::<Block>().unwrap_or_else(|e| {
        tracing::warn!(
            target: "srv-persist",
            "[srv-persist] bootstrap: failed to load blocks from wstore: {} — blocks start empty",
            e
        );
        Vec::new()
    });
    let mut state = state.lock().await;
    for ws in &workspaces {
        // The persistent `Workspace` carries two ordered lists:
        // `tabids` (regular tabs) and `pinnedtabids` (sticky tabs).
        // Both are equally "owned by this workspace" for reducer
        // purposes — only their UX semantics differ. Concatenate
        // pinned-then-regular (pinning convention puts pinned tabs
        // first), then filter against the tabs we actually loaded
        // to drop dangling references defensively. (codex P1 #612.)
        let tab_ids: Vec<String> = ws
            .pinnedtabids
            .iter()
            .chain(ws.tabids.iter())
            .filter(|tid| tabs.iter().any(|t| &t.oid == *tid))
            .cloned()
            .collect();
        let active_tab_id = if !ws.activetabid.is_empty()
            && tab_ids.iter().any(|tid| tid == &ws.activetabid)
        {
            Some(ws.activetabid.clone())
        } else {
            None
        };
        state.workspaces.insert(
            ws.oid.clone(),
            WorkspaceRecord {
                workspace_id: ws.oid.clone(),
                name: ws.name.clone(),
                tab_ids,
                active_tab_id,
            },
        );
    }
    for tab in &tabs {
        // Each tab needs to know its parent workspace_id, which the
        // persistent `Tab` struct doesn't carry directly — we recover
        // it from whichever workspace lists this tab id in EITHER
        // `tabids` OR `pinnedtabids`. Tabs whose parent isn't loaded
        // are skipped (orphans). (codex P1 #612.)
        let Some(workspace_id) = workspaces
            .iter()
            .find(|ws| {
                ws.tabids
                    .iter()
                    .chain(ws.pinnedtabids.iter())
                    .any(|tid| tid == &tab.oid)
            })
            .map(|ws| ws.oid.clone())
        else {
            tracing::warn!(
                target: "srv-persist",
                "[srv-persist] bootstrap: tab {} has no parent workspace — skipping",
                tab.oid
            );
            continue;
        };
        // Phase E.3 — filter dangling block ids on the same defensive
        // basis we apply to tabs above.
        let block_ids: Vec<String> = tab
            .blockids
            .iter()
            .filter(|bid| blocks.iter().any(|b| &b.oid == *bid))
            .cloned()
            .collect();
        // Phase E.4 (Option A) — bootstrap focused/magnified node from
        // the tab's LayoutState row so the reducer's view matches what
        // the user last saw on disk. Empty when the layout row isn't
        // found or has no value (matches `LayoutState` defaults).
        //
        // Phase E.4.B — also bootstrap `rootnode` (the layout tree).
        // Until the wcore-direct writers migrate to dispatch through
        // the new layout reducer arms (Phase 7), the reducer's
        // rootnode is a passive shadow — refreshed on startup, never
        // diverging from disk because no reducer-arm writers exist
        // yet at runtime.
        let (focused_node_id, magnified_node_id, rootnode) = if tab.layoutstate.is_empty() {
            (String::new(), String::new(), None)
        } else {
            match wstore.get::<crate::backend::obj::LayoutState>(&tab.layoutstate) {
                Ok(Some(layout)) => (
                    layout.focusednodeid,
                    layout.magnifiednodeid,
                    layout.rootnode,
                ),
                _ => (String::new(), String::new(), None),
            }
        };
        state.tabs.insert(
            tab.oid.clone(),
            TabRecord {
                tab_id: tab.oid.clone(),
                workspace_id,
                name: tab.name.clone(),
                block_ids,
                focused_node_id,
                magnified_node_id,
                rootnode,
            },
        );
    }
    for block in &blocks {
        // Phase E.3 — recover each block's parent tab via reverse
        // lookup against `state.tabs` (NOT raw `tabs` from SQLite):
        // tabs orphaned in the prior loop (no parent workspace) are
        // not in `state.tabs`, so blocks under them must also be
        // dropped to keep reducer state consistent. (reagent P1 #613.)
        let Some(tab_id) = state
            .tabs
            .values()
            .find(|t| t.block_ids.iter().any(|bid| bid == &block.oid))
            .map(|t| t.tab_id.clone())
        else {
            tracing::warn!(
                target: "srv-persist",
                "[srv-persist] bootstrap: block {} has no parent tab in reducer state — skipping",
                block.oid
            );
            continue;
        };
        state.blocks.insert(
            block.oid.clone(),
            BlockRecord {
                block_id: block.oid.clone(),
                tab_id,
            },
        );
    }
    // Phase E.5 — load Window→Workspace mappings. Used by sagas
    // (TearOff/Restore/CreateWindow/CloseWindow) that coordinate
    // window+workspace lifecycle. Skip windows whose `workspaceid`
    // refers to a workspace that didn't load — those are dangling
    // refs, same defensive treatment as orphan tabs/blocks.
    let windows = wstore.get_all::<Window>().unwrap_or_else(|e| {
        tracing::warn!(
            target: "srv-persist",
            "[srv-persist] bootstrap: failed to load windows from wstore: {} — windows start empty",
            e
        );
        Vec::new()
    });
    for window in &windows {
        if window.workspaceid.is_empty() {
            tracing::warn!(
                target: "srv-persist",
                "[srv-persist] bootstrap: window {} has empty workspaceid — skipping",
                window.oid
            );
            continue;
        }
        if !state.workspaces.contains_key(&window.workspaceid) {
            tracing::warn!(
                target: "srv-persist",
                "[srv-persist] bootstrap: window {} points at unknown workspace {} — skipping",
                window.oid, window.workspaceid
            );
            continue;
        }
        state.windows.insert(
            window.oid.clone(),
            WindowRecord {
                window_id: window.oid.clone(),
                workspace_id: window.workspaceid.clone(),
            },
        );
    }
    tracing::info!(
        target: "srv-persist",
        "[srv-persist] bootstrap loaded {} workspace(s) + {} tab(s) + {} block(s) + {} window(s) from wstore",
        state.workspaces.len(),
        state.tabs.len(),
        state.blocks.len(),
        state.windows.len()
    );
}