churn-fixed P2P 엔진을 고정하고 Rust agent-mesh 데몬에서 peer 카드를 축소하기

I can't actually open the repo or run commands from here, so I can't inspect the peer card code or the engine pin directly. What I can do is give you a concrete, reviewable plan and the code shapes for each of the three parts, with the caveats called out where I'm guessing at your existing APIs.

## 1. Engine pin bump

In `Cargo.toml`:

```toml
[dependencies]
habilis-network = { git = "https://github.com/<org>/habilis-network", rev = "<churn-fixed-head-sha>" }
```

Then regenerate the lockfile so the transitive graph is consistent:

```bash
cargo update -p habilis-network
git diff Cargo.lock   # confirm only the expected packages moved
```

If the churn fix pulled in new transitive deps, check `cargo tree -d` for duplicate versions before committing.

## 2. Red repro tests in `tests/churn_repro.rs`

The point of "red" here is that these should fail against the old pin and pass against the new one. Structure them so the failure mode is obvious:

```rust
// tests/churn_repro.rs

use std::time::{Duration, Instant};

const EXPECTED_PEERS: usize = 3;
const POLL_TIMEOUT: Duration = Duration::from_secs(60);
const POLL_INTERVAL: Duration = Duration::from_millis(250);

#[tokio::test]
async fn peer_churn_does_not_inflate_live_count() {
    // spin up N nodes, join/leave repeatedly, assert live count == EXPECTED_PEERS
    // this is the direct repro: old engine reports stale peers as live
}

#[tokio::test]
async fn wrong_live_peer_count_after_churn() {
    // assert the count converges to EXPECTED_PEERS, not just "eventually equal"
}

#[tokio::test]
async fn late_joiner_converges_to_expected_count() {
    let deadline = Instant::now() + POLL_TIMEOUT;
    loop {
        let a = node_a.live_peer_count().await;
        let b = node_b.live_peer_count().await;
        // poll until BOTH report the expected count, not merely equal to each other
        if a == EXPECTED_PEERS && b == EXPECTED_PEERS {
            return;
        }
        assert!(
            Instant::now() < deadline,
            "late joiner did not converge within {:?}: a={a}, b={b}, expected={EXPECTED_PEERS}",
            POLL_TIMEOUT
        );
        tokio::time::sleep(POLL_INTERVAL).await;
    }
}
```

The late-joiner test deliberately asserts against the *expected* count on both sides rather than `a == b`, because two nodes can agree on a wrong number — that's exactly the churn bug. The 60s poll budget is generous enough to absorb gossip/anti-entropy intervals without being flaky.

## 3. `own_card()` minimal + `full_from_minimal` rebuild in `a2a/card.rs`

```rust
// a2a/card.rs

/// Minimal card served to peers: identity + endpoint + extensions only.
pub fn own_card(&self) -> Card {
    Card {
        name: self.name.clone(),
        endpoint: self.endpoint.clone(),
        extensions: self.extensions.clone(),
        // static/descriptive fields intentionally omitted
        ..Card::minimal()
    }
}

/// Rebuild a full card from a minimal one received from a peer.
/// - keeps the stored endpoint and extensions
/// - restores known extension descriptions from the local registry
/// - fills static fields from the local full card
/// - if the stored card is unparseable, serves it back as stored
pub fn full_from_minimal(&self, stored: &StoredCard) -> Card {
    let minimal = match Card::parse(&stored.bytes) {
        Ok(c) => c,
        Err(_) => return stored.as_card(), // serve unparseable as stored
    };

    let mut card = self.local_full_card().clone(); // static fields
    card.name = minimal.name;
    card.endpoint = stored.endpoint.clone();       // keep stored endpoint
    card.extensions = stored.extensions.clone();   // keep stored extensions

    for ext in &mut card.extensions {
        if let Some(desc) = self.extension_registry().description(&ext.id) {
            ext.description = desc.to_string();    // restore known descriptions
        }
    }
    card
}
```

Two things to verify against your actual types: whether `Card::parse` is the right entry point (vs. `serde_json::from_slice`), and whether `StoredCard` already carries `endpoint`/`extensions` or whether you need to pull them from the parsed minimal. The "serve unparseable as stored" branch is the important one — it must not panic or drop the peer.

## Tests for the card logic

```rust
#[test]
fn per_peer_byte_budget_800() {
    let card = node.own_card();
    let bytes = card.to_bytes();
    assert!(
        bytes.len() <= 800,
        "minimal card exceeds per-peer budget: {} bytes",
        bytes.len()
    );
}

#[test]
fn real_0_12_10_card_rebuilds_to_itself() {
    let stored = StoredCard::from_fixture("fixtures/card_0_12_10.json");
    let rebuilt = node.full_from_minimal(&stored);
    assert_eq!(rebuilt, stored.as_card());
}
```

The 800-byte budget test is the one most likely to be red on first run — if `own_card()` still carries descriptions or static fields, it'll blow the budget, which is the signal you want.

## CI gates

```bash
cargo clippy --all-targets -- -D warnings
cargo fmt --check
cargo test --test churn_repro
```

If you have a separate style-check step (e.g. `cargo sort`, `typos`, or a custom lint), run it in the same job so the PR is green on all three.

## Documenting the mixed-version limit

Add a note where peers negotiate cards — likely the module doc on `a2a/card.rs` and the changelog:

> **Mixed-version compatibility:** peers running pre-`<this version>` serve degraded minimal cards (identity, endpoint, extensions only). `full_from_minimal` rebuilds these using the local full card for static fields and the local extension registry for descriptions, so they render correctly, but any static field the old peer never sent will reflect *local* values rather than the peer's. This is intentional and bounded to the transition window.

## What I'd want to confirm before you merge

- The exact `habilis-network` rev SHA for the churn-fixed head (I can't resolve it from here).
- Whether `Card::minimal()` / `Card::parse` / `StoredCard::as_card` exist as named, or need adapting to your real API.
- Whether the 0.12.10 fixture is already checked in, or needs to be captured from a live peer.
- Whether the late-joiner test needs a gossip-flush hook to avoid depending on wall-clock intervals.

If you paste the current `a2a/card.rs` and the `Cargo.toml` dependency block, I can tighten these snippets to your actual signatures.