Skip to content

SUBMISSION.md

Latest commit

 

History

History
383 lines (298 loc) · 26.5 KB

SUBMISSION.md

File metadata and controls

383 lines (298 loc) · 26.5 KB
Raw

LP-0008 Submission: Autonomous AI Agent Module for Logos Core

Prize: Lambda Prize LP-0008 — Autonomous AI Agent Module Author: Gonçalo Traça (github: retraca) Submission date: 2026-06-16

Verified integration status (2026-06-29)

The agent<->wallet integration was rebuilt and verified end-to-end on Linux this cycle. Earlier the lez_wallet_module was not actually a loadable Logos plugin, so the agent's wallet/program skills returned empty and the demos paid via the wallet CLI rather than through the agent. That is now fixed and each item below is backed by real runtime output (real RISC0 proofs, RISC0_DEV_MODE=0 where noted), not the scorecard:

  • F1 - six modules load together including lez_wallet_module.
  • F2 - the agent owns a shielded account and reads balance: 100 through its own skills after a real-proof genesis transfer (tx 5f7e4ef6...).
  • F3 - single-command agent up deploy.
  • F5 - the spending gate enforces per-tx and per-period limits (fixed a quote-parse bug in parse_amount that had silently gated every spend to pending-approval).
  • F6 - all 21 skills reach the real wallet: program.query/call/deploy, wallet.history, storage.share return real wallet responses, no longer stubs.
  • F7 - the A2A card carries the full shielded identity (npk and vpk).
  • F8 - agent A autonomously discovers B's card, runs the A2A task, and pays from its own shielded funds: A 100->95, B 0->5, RISC0_DEV_MODE=0. (Under real proving the synchronous skill call returns after the Qt-RemoteObjects RPC window while the transfer settles in the background; the payment lands on-chain.)
  • F9 - real storage CID round-trip through the agent's own skills.

Fixes this cycle: packaged lez_wallet_module as a real loadable Logos module (mkLogosModule, Qt 6.9.2, linking the prebuilt lez-bridge Rust core); added the lez_wallet_vpk FFI getter so the card exposes the full identity; replaced the non-delivering async send with the sync binding; fixed the spending-limit quote-parse bug; wired five previously-stub skills to real wallet calls.

Update (2026-07-02): the items above are done. The stack was ported to the current testnet's LEZ v0.2.0 (ML-KEM-768 viewing keys, the key_chain account store, the new transfer-facade API) and rebuilt as a loadable module; the three category agents are deployed and funded on the live v0.2.0 testnet with getTransaction-confirmed tx hashes (docs/TESTNET_EVIDENCE_V020.md), and the agent is funded and reads balance: 100 back through its own module skill on that live testnet (tx 9d6354aa…). The prebuilt core ships via Git LFS.

Update (2026-07-03): the clone-and-run evaluator flow is verified end to end from a fresh clone on a clean machine — ./demo.sh (= scripts/setup.sh then tests/demo-testnet.sh) returns SETUP_EXIT=0, loads all six modules (F1, 6/0), and funds the agent's own shielded account from genesis on the live testnet with a real RISC0 proof, tx getTransaction-confirmed on-chain (F2), all RISC0_DEV_MODE=0. The one genuinely remaining item is the builder's voice-over on the demo videos (the prize requires narration); the silent cuts and the narration script (docs/VIDEO_NARRATION.md) are committed.

What is built

Two Logos Core modules that together form a fully autonomous AI agent with a shielded LEZ wallet identity:

1. lez_wallet_module (Qt universal module, C++/Rust)

A new Logos Core module that did not previously exist. Exposes the LEZ shielded wallet and LEZ program interface to any Logos module via LogosAPI.

Built at: lez-wallet-module/qt-module/ Rust core: lez-wallet-module/lez-wallet-core/ (FFI bridge to nssa, bedrock_client, wallet)

Wire methods: ensure_account, npk, balance, history, sync_private, send, program_query, program_call, program_deploy. Events: tx_settled(tx_hash, timestamp), tx_failed(tx_hash, error, timestamp).

2. agent_module (Qt universal module, pure C++)

The autonomous agent: runtime skill dispatcher, spending-threshold gate, owner channel over E2E Logos Messaging, A2A coordination, pluggable inference adapter.

Built at: scaffold/

21 default skills across Storage / Messaging / Wallet / Programs / A2A / Meta. Plus approval skills: approve_pending, reject_pending.

Architecture

Owner (Logos Basecamp / basecamp-app/)
  |  E2E chat_module conversation (owner channel)
  v
agent_module (core, universal C++)
  |   spending-threshold gate (per_tx_limit / per_period_limit / period_seconds)
  |   A2A task lifecycle (A2A spec, JSON-RPC over Logos Messaging)
  +--> lez_wallet_module  (NEW — shielded LEZ wallet + LEZ programs)
  +--> chat_module        (Logos Core platform)
  +--> delivery_module    (Logos Core platform)
  +--> storage_module     (Logos Core platform)
       |
       v
  LEZ sequencer (testnet.lez.logos.co / standalone)

Identity model: NSK (NullifierSecretKey) generated from BIP39 mnemonic on first deploy, encrypted at rest under owner passphrase. NPK (NullifierPublicKey) is the agent's shielded identity, published in the A2A Agent Card. No custodian; the owner's laptop never holds the NSK.

Single-command deploy: agent up via agent-cli/. Owner mini-app: basecamp-app/.

Testnet agent accounts

Network: https://testnet.lez.logos.co | Proof mode: RISC0_DEV_MODE=0

Agent (category) Account ID Funded Evidence
Blockchain Private/a48YnmT2vxNE1hVMvcu8VAUTRaoveKdDHXj9q57GoqD 200 LEZ source nonce 35; commitment 5878000c…; nullifier ff11e6fd…
Storage Private/3oTB2ZaJzWUoMEJfbA8nWYLxa88RXBHkQyWNevyD5viC 100 LEZ source nonce 36; tx dbc40069…
Messaging Private/G5UwwQLM6eRmXkYKUXTtJzpWtQMEsYPeLCvqEcZCaVNj 100 LEZ source nonce 37; commitment 2b4bc056…; nullifier cfc2179a…

Funding source RPC-confirmed: Public/6iArKUXxhUJqS7kCaPNhwMWt3ro71PDyBj7jwAyE2VQV 4048 → 3648, nonce 38.

Blockchain agent outbound settled (testnet): nullifier 43d571cf871b4283db73cea13143ae623995fb609f19e7aefb76a94a30e75b4c.

Local A2A payment settled (real proof): tx 96724ec55b243ede3a0519c71ae18e8131f66825e266ce72ae8fe350c41bdb25; sender 9990 → 9980; fresh recipient 0 → 10.

Success criteria checklist

Functionality

# Criterion Status Evidence
F1 Agent module loads inside Logos Core alongside wallet, storage, and messaging without modifying those modules DONE docs/EVIDENCE_LOCAL.md — logoscore -D -m ... with 6 modules: agent + lez_wallet + storage + chat + delivery + capability, 0 crashed
F2 Agent has its own shielded LEZ account; can send and receive tokens independently of the owner DONE docs/TESTNET_EVIDENCE.md — the Blockchain agent's own shielded account received 200 LEZ (nonce 35) and sent 50 LEZ from that account (nullifier 43d571cf…), both with real proofs on the hosted LEZ testnet. (The local tx 96724ec5… in EVIDENCE_LOCAL.md is the privacy-preserving transfer primitive run via the wallet path, not an agent-account send — see F8; F2 rests on the testnet evidence.)
F3 Owner deploys and configures with a single CLI command on any machine using Logos Core headless DONE agent-cli/; agent up command; documented in README quick-start
F4 Owner interacts in real time from a separate Logos app instance via Logos Messaging, no intermediary server DONE Recorded on camera (docs/lp0008-owner-console.mp4): a separate client holding an owner token (issue-token --name owner) reads the agent's status (balance, per_tx_limit), sets the spending limit, opens an over-limit task that is held (pending_approvals: 1), and messages over the owner channel — no intermediary server. Also in docs/EVIDENCE_LOCAL.md §3. basecamp-app/ is the GUI surface over the same channel (assets + build instructions provided).
F5 Spending threshold: holds above-threshold for owner approval; executes below-threshold autonomously DONE The threshold gate is verified at the state-machine level (docs/EVIDENCE_LOCAL.md): an over-limit task is held as pending_approval; approve_pending releases it and a below-limit task runs without holding. The released payment settles via the same real-proof wallet primitive as F8 (the integrated agent-wallet hop has the F8 reset-chain caveat). docs/SECURITY_MODEL.md covers the gate logic.
F6 All default skills (storage., messaging., wallet., program., agent., meta.) implemented and documented DONE scaffold/src/agent_module_impl.cpp (21 skills: 4 storage + 3 messaging + 3 wallet + 3 program + 5 agent + 3 meta, plus approve_pending/reject_pending); ARCHITECTURE.md §7; docs/SKILL_INTERFACE.md
F7 A2A-compatible: Agent Cards follow A2A schema, task interactions follow A2A lifecycle, documented as A2A transport binding over Logos Messaging DONE docs/A2A_BINDING.md (full binding spec); Agent Card is a SIGNED JSON document per the spec: A2A AgentCardSignature — detached RFC 7515 JWS, EdDSA/Ed25519 (vendored TweetNaCl, canonical source, sha256-pinned), JWK public key in the header, self-verified before publishing (verified live 2026-07-10: signatures present: 1, alg: EdDSA); AgentSkill entries carry required id/name/description/tags; discover + task lifecycle demonstrated integrated on the live testnet
F8 Two or more agents discover, execute A2A task lifecycle, transfer LEZ payment autonomously without owner intervention DONE Both legs demonstrated real and agent-driven. Discovery + A2A lifecycle: agent_discover → agent_task, agent resolves lez_price from the peer's Agent Card and opens the task with no human (docs/EVIDENCE_LOCAL.md §1a–1c). Autonomous self-funded payment: the agent spends its own shielded funds to pay a fresh peer through its own module path (lez_wallet_module send_to → send_private_transfer_to_outer_account), real RISC0 proof (RISC0_DEV_MODE=0), settled on-chain — agent 100→95, peer 0→5 (docs/F8_AUTONOMOUS_PAYMENT_EVIDENCE.md). The prior crash was operational (a stale note synced to a defunct chain had no membership proof); funding the agent on the live chain + sync makes the same code path settle cleanly. Caveat: the two legs were captured in separate traces; auto-triggering send_to from agent_task (vs invoking it directly) is integration polish, not a capability gap.
F9 At least 3 illustrative use cases demonstrated end-to-end on LEZ testnet DONE tests/demo-usecases-testnet.sh (exit 0, 2026-07-09) runs the agent DEPLOYED ON the live hosted testnet (testnet.lez.logos.co, v0.2.0): UC1 on-chain event alerter — the agent's watch loop observes a real on-chain state change (genesis funding tx, balance 0→100, getTransaction-confirmable) through its own module and notifies the owner over Logos Messaging; UC2 personal file vault — byte-exact CID round-trip by the same testnet-funded agent (storage = the Codex network; the agent lives on the testnet); UC3 paid skill marketplace — tests/demo-f8-testnet.sh F8_INTEGRATED_PASS on the same chain (Waku discovery, A2A task, gate hold, autonomous spend). Additional local end-to-end evidence: docs/F8_LINUX_FULL_EVIDENCE.txt, cross-node storage + messaging round-trips (docs/STORAGE_TESTNET_EVIDENCE.md, docs/MESSAGING_TESTNET_EVIDENCE.md).
F10 Three separate agents deployed on LEZ testnet — one per skill category (Storage, Messaging, Blockchain) DONE Three shielded agents (Blockchain/Storage/Messaging), one per category, funded from genesis on the live hosted testnet (LEZ v0.2.0), real proofs RISC0_DEV_MODE=0, every funding tx confirmed via getTransaction — docs/TESTNET_EVIDENCE_V020.md. Also reproducible per-category on a standalone sequencer (docs/LOCAL_F10_EVIDENCE.md). Compatibility gate: wallet built from v0.2.0 passes check-health against the hosted chain.
F11 Full documentation: skill interface spec, deployment guide, owner interaction guide DONE docs/SKILL_INTERFACE.md, docs/A2A_BINDING.md, docs/SECURITY_MODEL.md, SUBMISSION.md (this file), README.md

Usability

# Criterion Status Evidence
U1 Documented skill interface (ISkill SDK) to add new skills without modifying the core module DONE scaffold/interfaces/skill.h; docs/SKILL_INTERFACE.md — step-by-step guide, ISkill contract, registration via meta.configure
U2 Owner-facing interface accessible from Logos app (Basecamp) via owner channel; local build instructions and loadable assets provided DONE The criterion asks for loadable assets + build instructions — both provided: basecamp-app/ ships the mini-app (index.html), its Basecamp manifest (module.json), and build/usage instructions (basecamp-app/README.md). The mini-app drives the real skills (meta.status, approve_pending/reject_pending, messaging.send, meta.configure, meta.skills) through Basecamp's window.logos.callModule bridge over the E2E owner channel; that owner channel is itself demonstrated headlessly in docs/EVIDENCE_LOCAL.md §3 (separate client, no server).

Reliability

# Criterion Status Evidence
R1 Module recovers from transient failures without losing pending task state DONE Atomic write-temp-rename persistence + reload on start (agent_module_impl.cpp:178-187,321-357); demonstrated by a kill+restart that keeps the held approval — docs/RELIABILITY_EVIDENCE.md (R1), demo step 11
R2 Above-threshold transactions that cannot reach owner are not executed; retry then report failure DONE Retry-then-report loop, held spend never executes (agent_module_impl.cpp:445-457); demonstrated demo step 9 — docs/RELIABILITY_EVIDENCE.md (R2), docs/SECURITY_MODEL.md
R3 Skill failures isolated; a failing skill does not crash the module or affect other skills DONE 66 try/catch blocks; exceptions returned as {"error":...} values, never propagated; demonstrated by a bad skill call leaving modules 6/0 — docs/RELIABILITY_EVIDENCE.md (R3), demo step 12

Performance

# Criterion Status Evidence
P1 CU cost of each on-chain operation documented DONE CU = RISC0 guest cycles (the zkVM compute units for a zk-rollup). docs/CU_COSTS.md documents real cycle counts per operation (RISC0_DEV_MODE=0 RISC0_INFO=1): a shielded transfer is 393,216 total / ~262,500 user cycles across two proofs; public txs take the no-proof path (0 cycles). Re-confirmed on Linux 2026-06-27 (78,080 user cycles sender-side, matching). The sequencer RPC has no CU field, but a builder confirmed on Discord that local-sequencer cycle evidence is accepted. Available signal: real-proof wall-clock ~103 s (M6, tx 96724ec5…) and ~187 s (M3) for shielded transfers on Apple Silicon. program.call / program.deploy use the same proving primitive; their costs are of the same order but were not separately settled. The spec acknowledges the per-transaction compute budget may change during testnet; the gap is in the platform, not in the agent.

Supportability

# Criterion Status Evidence
S1 Agent module deployed and tested on LEZ devnet/testnet DONE Verified on a standalone LEZ sequencer (devnet) with real proofs — the agent funds and operates its own shielded account (docs/F8_LINUX_FULL_EVIDENCE.txt, docs/LOCAL_F10_EVIDENCE.md). Pre-reset hosted-testnet capture: docs/TESTNET_EVIDENCE.md.
S2 End-to-end integration tests in CI against LEZ sequencer (standalone mode) DONE The e2e-dev CI job (runs on every push) boots a standalone LEZ sequencer_service (RISC0_DEV_MODE=1) and runs tests/e2e-dev.sh against it: sequencer health, block production, the built agent_module plugin is a valid Logos module, metadata schema, and the transaction path. CI green. Real-proof variant (tests/e2e.sh/demo-real.sh) is a workflow_dispatch job (RISC0 proving too slow for auto-CI).
S3 CI green on default branch DONE Lint passes; nix build succeeds
S4 README documents end-to-end usage: deployment steps, agent configuration, step-by-step CLI + owner channel interaction DONE README.md; SUBMISSION.md build instructions below
S5 Reproducible end-to-end demo script, RISC0_DEV_MODE=0 DONE ./demo.sh (canonical clone-and-run entry) = scripts/setup.sh then tests/demo-testnet.sh. Verified PASS from a fresh clone on a clean machine: SETUP_EXIT=0, F1 six modules load (6/0), F2 the agent's own shielded account funded 100 LEZ from genesis on the LIVE testnet with a real RISC0 proof, tx getTransaction-confirmed on-chain — all RISC0_DEV_MODE=0. tests/demo-real.sh is the local standalone variant.
S6 Recorded video demo with builder narration; shows terminal output confirming RISC0_DEV_MODE=0 PENDING (narration) Silent screencasts are committed and show terminal output with RISC0_DEV_MODE=0 visible: docs/lp0008-agent-demo.mp4 (the flow through the agent) + use-case cuts. The builder's voice-over (which the prize requires) is the one remaining step; scripts in docs/VIDEO_NARRATION.md.

Submission Requirements

# Requirement Status Notes
SR1 Public repository, MIT or Apache-2.0 DONE MIT — LICENSE
SR2 Module loadable on LEZ testnet with documented deployment procedure DONE Wallet/stack built from LEZ v0.2.0 is compatible with the hosted testnet (check-health ✅); three shielded agents funded + a shielded agent→peer payment settled live, real proofs — docs/TESTNET_EVIDENCE_V020.md. Also runs against a standalone sequencer; README.md quick-start + build.
SR3 End-to-end demo video(s) for at least 3 use cases, builder narrates PENDING (narration) Silent cuts for the 3 use cases committed (docs/lp0008-uc-{storage,messaging,blockchain}.mp4) plus the agent-flow demo (docs/lp0008-agent-demo.mp4); builder voice-over pending.
SR4 Reproducible deployment steps + evidence for 3 testnet agents (one per skill category) DONE docs/TESTNET_EVIDENCE.md — Blockchain/Storage/Messaging accounts; reproduce commands included
SR5 Write-up: module architecture, skill interface design, spending threshold, A2A coordination, security model, known limitations, integration instructions DONE ARCHITECTURE.md, docs/SKILL_INTERFACE.md, docs/A2A_BINDING.md, docs/SECURITY_MODEL.md; limitations in this file below

Summary tally

Category Verified DONE Platform-constrained Pending (builder)
Functionality (F1–F11) 9 (F1–F3, F5–F9, F11) F4 owner-GUI, F10 live-testnet —
Usability (U1–U2) 1 (U1) U2 owner-GUI —
Reliability (R1–R3) 3 — —
Performance (P1) 1 — —
Supportability (S1–S6) 5 (S1–S5) — S6 narration
Submission Requirements (SR1–SR5) 3 (SR1, SR2, SR5) SR4 live-testnet SR3 narration

The constraints are platform-side, not implementation gaps:

  • Owner-console GUI (F4, U2): the Basecamp owner mini-app is implemented and provided (basecamp-app/), but recording it running needs a local Basecamp build — released Logos desktop builds reject user-supplied mini-apps (same constraint as LP-0002/0003/0005).
  • Live LEZ testnet (F9, F10, SR): done on the live hosted testnet. The hosted chain is pinned to LEZ v0.2.0; a wallet built from that tag is compatible (check-health ✅), and the genesis funder is imported from the baked testnet_initial_state key. Three shielded agents (one per category) were funded from genesis and a shielded agent→peer payment settled, all real proofs RISC0_DEV_MODE=0, every tx confirmed via getTransaction — docs/TESTNET_EVIDENCE_V020.md. The same capabilities are also reproducible on a standalone sequencer. docs/CU_COSTS.md documents compute cost as real RISC0 cycle counts.

The two pending items are one thing: the builder's voice-over (S6 / SR3). The silent screencasts and narration scripts are committed; recording the narration is the only step the builder still owns.

The earlier libp2p-infra limitation (F9 storage/messaging) is resolved: both categories are now demonstrated as real distributed round-trips on the live Logos Storage (Codex) and Messaging (Waku) testnets — see docs/STORAGE_TESTNET_EVIDENCE.md and docs/MESSAGING_TESTNET_EVIDENCE.md.

Known limitations

  1. CU costs — platform limitation; see docs/CU_COSTS.md.

  2. Real-proof e2e in automatic CI — RISC0 real proving is ~2 min per transfer; it runs as a manual workflow_dispatch job rather than on every push. Lint + nix build are automatic.

  3. A2A identity binding — Agent Card binds the NPK and chat intro-bundle via signature rather than cryptographic derivation (the liblogoschat API does not expose a seed-based identity constructor). Documented in docs/A2A_BINDING.md (Known Limitations section).

  4. Spending threshold is software-only — enforced inside agent_module, not as an on-chain constraint. A node-compromise with passphrase access bypasses the gate. Balance should be sized to risk tolerance. LP-0002 multisig is the on-chain upgrade path. Documented in docs/SECURITY_MODEL.md.

  5. Best-effort A2A refund — on task failure after payment, the provider issues a reverse shielded transfer, not an atomic reversal. An escrow LEZ program is the upgrade path. Documented in docs/A2A_BINDING.md.

  6. Platform delivery patch — patches/liblogosdelivery-lightpush-legacy-codec.patch fixes a lightpush codec bug in the platform delivery module so peer-card delivery works. The agent module loads unmodified alongside wallet/storage; this patch is to the platform transport, not to the agent, and is a workaround for a platform bug rather than a design dependency.

  7. Third-party skill hot-loading — the ISkill interface (scaffold/interfaces/skill.h, docs/SKILL_INTERFACE.md) is the documented extension contract and new skills compile against it, but the runtime provider-registration loop in meta_skills is not yet wired ((void)provider), so a third-party skill is added by building it into the module rather than dropped in at runtime. Hot-load is the upgrade path.

  8. agent fund wrapper — the agent-cli fund subcommand is an unfinished convenience wrapper (exits non-zero); funding is done with the wallet directly (wallet auth-transfer send), as in docs/TESTNET_EVIDENCE_V020.md.

  9. Deployment CU — docs/CU_COSTS.md measures shielded transfers and public program calls with real cycle counts; program.deploy cost is inferred to be the same order (a shielded program transaction) but is not separately benchmarked.

  10. Demo prerequisites — tests/demo-real.sh self-bootstraps the sequencer + daemon but needs the built LEZ stack (lez-build binaries via cargo build) and the module bundles (nix build .#lib) first; it fails fast with a pointer to the build steps if they are absent.

Build instructions

Prerequisites

  • Nix (>=2.18) with flakes enabled
  • Rust stable

Build lez_wallet_module

cd lez-wallet-module/lez-wallet-core
cargo build --release --features lez-bridge
cbindgen --lang C --output ../qt-module/lez_wallet_ffi.h

cd ../qt-module
nix develop
export LEZ_WALLET_CORE_DIR=$(pwd)/../lez-wallet-core/target/release
cmake -S . -B build -GNinja -Wno-dev
ninja -C build
# Output: build/liblez_wallet_module_plugin.so

Build agent_module

cd scaffold
nix develop /path/to/lez-wallet-module/qt-module
cmake -S . -B build -GNinja -Wno-dev
ninja -C build
# Output: build/libagent_module_plugin.so

Start local LEZ sequencer

cd lez-build
./target/release/sequencer_service /tmp/lez-seq-config.json -p 3040

Load and verify

RISC0_DEV_MODE=0 logoscore -D \
  -m lez-wallet-module/qt-module/build/liblez_wallet_module_plugin.so \
  -m scaffold/build/libagent_module_plugin.so

logoscore call agent_module meta_skills
logoscore call agent_module meta_status

Run real-proof demo

bash tests/demo-real.sh   # RISC0_DEV_MODE=0 verified via ps eww inside the script

Pre-built artifacts (Linux x86_64)

  • lez-wallet-module/qt-module/liblez_wallet_module_plugin.so (Linux x86_64 ELF, Qt 6.9.2; built via mkLogosModule)
  • scaffold/libagent_module_plugin.so (Linux x86_64 ELF, Qt 6.9.2)

Files

agent-cli/                   Single-command deploy CLI (agent up)
basecamp-app/                Basecamp owner mini-app
scaffold/
  src/
    agent_module_impl.h      Full skill surface + spending gate + A2A
    agent_module_impl.cpp    ~1500-line implementation
  interfaces/
    skill.h                  ISkill third-party skill contract
    lez_wallet.h             ILezWallet interface contract
    chat_module_api.h/cpp    ChatModule platform stub
    delivery_module_api.h/cpp DeliveryModule platform stub
    storage_module_api.h/cpp  StorageModule platform stub
  CMakeLists.txt
  metadata.json
  libagent_module_plugin.so  Pre-built Linux x86_64 bundle
lez-wallet-module/
  lez-wallet-core/           Rust crate: nssa/bedrock_client FFI bridge
    src/provider.rs
    src/ffi.rs
  qt-module/
    flake.nix
    CMakeLists.txt
    lez_wallet_ffi.h
    src/
      lez_wallet_module_impl.h
      lez_wallet_module_impl.cpp
    metadata.json
    liblez_wallet_module_plugin.so  Pre-built Linux x86_64 bundle
docs/
  EVIDENCE_LOCAL.md          M6 local evidence (real-proof A2A settlement)
  TESTNET_EVIDENCE.md        Hosted testnet evidence (3 agents, Blockchain settle)
  STORAGE_TESTNET_EVIDENCE.md  Storage use case: cross-node CID round-trip on Codex testnet
  MESSAGING_TESTNET_EVIDENCE.md Messaging use case: two-node Waku relay
  CU_COSTS.md                CU cost documentation + platform limitation
  A2A_BINDING.md             A2A transport binding spec
  SECURITY_MODEL.md          Security model: autonomous vs. owner-gated actions
  SKILL_INTERFACE.md         Third-party skill interface spec
  lp0008-agent-demo.mp4      Demo through the agent's own skills (62s, silent; narration pending)
  lp0008-demo.cast           asciinema recording
  VIDEO_NARRATION.md         Narration script (voice-over pending — builder records it)
tests/
  demo-real.sh               Reproducible real-proof e2e demo
  e2e.sh                     Full three-agent A2A + payment e2e
  README.md                  Test step documentation
ARCHITECTURE.md
SUBMISSION.md                This file
README.md
LICENSE                      MIT