Function load_attestation

atomic-cli/src/commands/memory/bridge.rs:202–280

Load a memory's attestation and classify it against the current source (`inputs`). Prefers the tracked vault entry, falling back to the legacy sidecar. A missing attestation is `None`; a corrupt/malformed one is treated as `None`/skipped with a warning (fail-open, so a read still works on the raw node). Same mechanism as the intent bridge.

(
    repo: &Repository,
    id_or_path: &str,
    inputs: &MemLiftInputs,
)

/// as `None`/skipped with a warning (fail-open, so a read still works on the
/// raw node). Same mechanism as the intent bridge.
pub fn load_attestation(
    repo: &Repository,
    id_or_path: &str,
    inputs: &MemLiftInputs,
) -> CliResult<Attestation> {
    // 1) Tracked vault entry (authoritative). The body is the pretty JSON-LD
    //    node (+ trailing '\n'); parse it straight to a MemoryNode.
    let vpath = attestation_vault_path(id_or_path);
    if let Some(entry) = repo.vault_retrieve(&vpath).map_err(CliError::Repository)? {
        let raw = String::from_utf8_lossy(&entry.content_bytes);
        match serde_json::from_str::<MemoryNode>(raw.trim_end()) {
            Ok(node) => {
                let recorded = serde_json::from_str::<Value>(&entry.frontmatter_json)
                    .ok()
                    .and_then(|v| {
                        v.get("sourceContentHash")
                            .and_then(Value::as_str)
                            .map(str::to_owned)
                    });
                let current = source_content_hash(inputs);
                return Ok(match recorded {
                    Some(h) if h == current => Attestation::Fresh(Box::new(node)),
                    _ => Attestation::Stale(Box::new(node)),
                });
            }
            Err(e) => {
                eprintln!("warning: ignoring malformed tracked attestation {vpath}: {e}");
                // fall through to the legacy sidecar
            }
        }
    }

    // 2) Legacy sidecar fallback (pre-upgrade attestations). Memory has no
    //    PREFIX-N ambiguity, so there is exactly ONE candidate path.
    let path = attested_sidecar_path(repo, id_or_path);
    if !path.exists() {
        return Ok(Attestation::None);
    }
    let raw = std::fs::read_to_string(&path).map_err(CliError::Io)?;
    let artifact: Value = match serde_json::from_str(&raw) {
        Ok(v) => v,
        Err(e) => {
            eprintln!(
                "warning: ignoring unreadable attestation sidecar {}: {e}",
                path.display()
            );
            return Ok(Attestation::None);
        }
    };
    let node_val = match artifact.get("node") {
        Some(n) => n.clone(),
        None => {
            eprintln!(
                "warning: attestation sidecar {} has no 'node' — ignoring",
                path.display()
            );
            return Ok(Attestation::None);
        }