Research: porting block/buzz into ainb (ACP, chat surfaces, federation)

[stevengonsalvez]

Research: Porting block/buzz features into ainb, ACP, chat surfaces, federation

Date: 2026-07-31 14:56:19
Repository: agents-in-a-box (worktree agents-in-a-box--f-buzz--19533eb1)
Branch: f/buzz
Commit: 10165ef
Research Type: Comprehensive (Codebase ainb + Codebase buzz@39ce3df + Web)
Buzz snapshot: https://github.com/block/buzz @ 39ce3df, cloned to session scratchpad
Spec: research/2026-07-31_buzz-acp-research-spec.md

Research Question

Comprehensively research block/buzz: what features can ainb port? Would ACP (Agent Client Protocol) work better than what ainb has today? Design options for an ainb chat feature (claude/codex backends) and/or an independent fleet chat with broadcast. Is anything useful for making local-only ainb federated across systems?

Executive Summary

Buzz is not a small ACP chat app, it is a self-hosted, Nostr-relay-based team workspace where humans and AI agents are equal members. Three verdicts came out of the research: (1) ACP: hybrid-adopt: add ACP as a new provider transport at ainb's existing ProviderAdapter seam for chat-grade agent sessions, keep tmux for interactive terminal sessions, do not touch the hangar plugin or fleet daemon protocols; (2) Chat: build the daemon-level chat bus first: the fleet daemon already has composer→send→broadcast→receipt plumbing proven against two clients, the only missing piece is a persisted message model; (3) Federation: Tailscale/SSH over the existing daemon socket now, adopt buzz's NIP-42-style challenge auth and NIP-OA owner-attestation identity pattern only when a second person's machines join; buzz itself has zero relay-to-relay federation in code today.

Key Findings

• ainb already has 80% of a chat transport. The macOS Fleet app ships a per-session prompt composer and a multi-recipient broadcast form with receipts, over hangar.sock with capability gating, revision-log replay and resync (ainb-tui/crates/ainb-hangar-proto/src/fleet.rs:727-742, apps/ainb-fleet-macos/Sources/FleetUI/FleetWindowView.swift:430-481). The gap is a persisted message model, not a wire protocol.
• ainb's agent transport is terminal scraping; ACP is the structured replacement at exactly one seam. Today: tmux send-keys with a 1000 ms paste settle and 3× Enter retry (ainb-tui/crates/ainb-fleet-core/src/fleet/send/tmux.rs:84-104), observation by capture-pane + tailing Claude's own JSONL. ACP provides session/prompt, streamed session/update (message/thought/tool_call/plan), session/request_permission, cancellation and steering, the structured versions of everything the needs/attention pipeline currently scrapes for. The ProviderAdapter trait (ainb-tui/crates/ainb-fleet-core/src/fleet/provider.rs:149-166) is already shaped to host it.
• ACP ecosystem is production-grade for exactly ainb's providers. Official adapters: claude-agent-acp (Claude Code), codex-acp (Codex); Gemini CLI and Copilot CLI native (copilot --acp --port is even TCP). First-party Rust crate agent-client-protocol v1.6.0. Co-governed Zed + JetBrains, Apache 2.0. Weakness: remote transport is spec-level WIP; stdio-only baseline.
• Buzz's cleanest architectural trick: the chat timeline only ever gets the agent's final message. Thinking, tool calls, plans, permission requests, token/cost stream over a separate encrypted observer side-channel (kind 24200 carrying raw ACP session updates), reduced into a side transcript. The chat renderer never handles partial markdown.
• Buzz has no federation. buzz-relay-mesh is pod-to-pod QUIC inside one deployment and fails closed against foreign relay identities (buzz/crates/buzz-relay-mesh/src/membership.rs:90-102). What buzz federates is identity: a portable keypair, NIP-42 challenge auth (~50 transport-agnostic lines), and NIP-OA owner-attestation ("my agents act under my key, bounded and revocable").
• Top standalone lift candidates from buzz (zero relay/Postgres coupling): buzz-dev-mcp (MCP tool server with _Stop/_PostCompact lifecycle hooks), buzz-workflow (YAML trigger/action/cron DSL behind an action-sink seam), buzz-persona (.persona.md parser/merge), the buzz-acp AgentPool/queue/circuit-breaker patterns, and buzz-voice (offline TTS).

Detailed Findings

1. What buzz is (architecture in one screen)

┌──────────────┐  ┌──────────────────┐  ┌────────────┐
│ Desktop      │  │ buzz-acp harness │  │ buzz-cli   │
│ (Tauri+React)│  │ ACP stdio ndjson │  │ agent-first│
│ mobile (Flu.)│  │ goose/codex/     │  │ JSON CLI   │
└──────┬───────┘  │ claude pool 1-32 │  └─────┬──────┘
       │ WS+REST  └────────┬─────────┘        │
       ▼                   ▼ WS+REST          ▼
┌─────────────────────────────────────────────────────┐
│ buzz-relay (Axum): NIP-01 signed events, kind-based │
│ channels·threads·DMs·canvas·media·search·audit·git· │
│ workflows·huddles(voice)·presence                   │
└──────┬──────────────┬──────────────┬────────────────┘
   Postgres         Redis         S3/MinIO
   (events+FTS)     (pubsub)      (Blossom media)

Every action is a signed Nostr event with a kind integer; new feature = new kind, zero breaking changes. The relay is the single source of truth; agents are members with their own keypairs, channel memberships and audit trails. Minimum self-host footprint is 5 containers (relay, Postgres, Redis, MinIO, minio-init) with no feature flags to drop any of them and no sqlite path (buzz/deploy/compose/compose.yml).

2. How buzz uses ACP (buzz-acp deep dive)

• Hand-rolled protocol client, no upstream crate. JSON-RPC 2.0, newline-delimited over child stdio, 10 MB line cap (buzz/crates/buzz-acp/src/acp.rs:19-21). Deliberately squats protocol v2 ahead of the upstream RFD (acp.rs:126).
• Methods used: initialize, authenticate, session/new (with mcpServers + systemPrompt), session/prompt, session/cancel, session/set_config_option/set_model, plus steering extensions (_session/steering, goose-namespaced variants). Inbound: session/update (8 variants), session/request_permission. Unknown agent→client requests get -32601 so agents never hang. No fs/terminal capability advertised.
• Adapters spawned by name: goose acp, codex-acp, claude-agent-acp, buzz-agent (buzz/crates/buzz-acp/src/config.rs:694-700); npm-installed out of band. Codex needs a CODEX_CONFIG env deep-merge to open sandbox network access for the MCP child (config.rs:741-775).
• Session model: session per (agent process × channel), pool of 1–32 subprocesses with claim/return and channel affinity; context persists in the adapter across prompts; rotation by turn cap, owner !rotate, or model switch (buzz/crates/buzz-acp/src/pool.rs:556-596, 2093-2097). Idle timeout 620 s (reset on any stdout line and on tool_call), hard cap 7200 s; per-slot crash circuit breaker with jittered exponential backoff (buzz/crates/buzz-acp/src/lib.rs:1027-1136).
• Queueing: per-channel FIFO, at most one prompt in flight per channel, batch up to 50 events into one prompt, cross-channel fairness by oldest head (buzz/crates/buzz-acp/src/queue.rs:92-136). Mid-turn arrivals: Queue / Steer (default; non-cancelling injection, capability-gated because codex-acp answers unknown methods with {} success) / Interrupt / OwnerInterrupt.
• The key design decision: agent replies do NOT return via ACP. session/update chunks only feed logs and an encrypted owner-only observer feed (kind 24200). The agent posts to chat itself by running the buzz CLI via an MCP shell tool (instruction baked into the base prompt, buzz/crates/buzz-acp/src/base_prompt.md:5-24). The harness only publishes presence, typing, 👀/💬 reactions, observer frames, token metrics, and failure notices.
• Permissions: auto-approved (allow_once selected by kind), session-level permission mode pushed via session/set_config_option; never surfaced to the channel for action.
• MCP wiring: exactly one MCP server passed via ACP session/new (buzz-dev-mcp), which installs a 0700 tempdir PATH shim exposing rg, tree, buzz, git-credential-nostr, git-sign-nostr; the private key is moved from env into a 0600 keyfile so children never see it (buzz/crates/buzz-dev-mcp/src/shim.rs:33-58).
• Identity: one Nostr keypair per agent identity; --agents N is a concurrency knob, not N identities. @mention routing is p-tag equality against the agent's pubkey (buzz/crates/buzz-acp/src/lib.rs:2732-2738), plus an inbound author gate (owner-only default / allowlist / anyone).

3. What ainb has today (current-state map)

• Two local JSON-RPC 2.0 protocols, LSP-framed: plugin protocol over subprocess stdio (ainb-plugin-protocol, abi v2) and the hangar daemon protocol over ~/.agents-in-a-box/hangar.sock (0600, token auth via auth/hello, constant-time SHA-256 check; ainb-tui/crates/ainb-hangar-daemon/src/rpc/mod.rs:210-222). Daemon surface is ~150 methods and already includes chat-adjacent primitives: hangar/comment_add, comment_mention_preview, inbox_list, squad_fanout, attention/*, fleet/*.
• Agent transport is scraping. Inject: tmux send-keys -l -- + paste-settle + Enter-retry loop born from the "ATC heartbeat incident: 8 unsubmitted pastes" (ainb-tui/crates/ainb-fleet-core/src/fleet/send/tmux.rs:12-21,84-104). Observe: capture-pane with box-drawing-character heuristics for AskUserQuestion, plus re-implementing Claude Code's JSONL transcript path slugging (.../fleet/read/jsonl_tail.rs:16-49). Provider enum is Claude | Codex | Unknown, Gemini/Copilot launchable but not observable (.../fleet/types.rs:25-29).
• Fleet spine is chat-ready. fleet/negotiate (versioned), fleet/snapshot + fleet/subscribe with revision-contiguous replay and fleet/resync_required, capability ids per write surface, fleet/broadcast {target_keys, text, idempotency_key} returning receipts with Pending|Delivered|Failed|Unknown|Rejected (ainb-tui/crates/ainb-hangar-proto/src/fleet.rs:290-352, 624-663, 727-742). Proven against two independent clients (hangar-tui plugin, Swift app).
• Remote already exists in two places: ainb-web (axum; WS terminal, SSE events, bearer-token auth, refuses non-loopback bind without token; ainb-tui/crates/ainb-web/src/config.rs:97-136) and ainb fleet bridge (Telegram/Slack/Discord two-way relay behind a FleetTransport trait seam; ainb-tui/crates/ainb-core/src/fleet/bridge/relay.rs:1-30).
• Chat precedents: dormant ClaudeChatComponent in core (talks the Anthropic API directly, #![allow(dead_code)]; ainb-tui/crates/ainb-core/src/components/claude_chat.rs:14); the Multica exploration explicitly lists standalone chat as an unstarted gap and lands on "coordination is entirely comment-driven; agents are team members" (docs/explorations/multica-reference/README.md:19-26, docs/hangar/proofs/multica-comparison.md:70,202,250).
• ACP appears zero times in the ainb repo.

4. ACP ecosystem (web survey, fetched 2026-07-31)

• Spec: JSON-RPC 2.0 over stdio; initialize negotiates integer protocolVersion (stable = 1; v2 schema in alpha). Remote transport (HTTP/WebSocket) explicitly WIP in the spec (agentclientprotocol.com/overview/architecture).
• Libraries: Rust agent-client-protocol v1.6.0 (2026-07-21), TS @agentclientprotocol/sdk, plus Python/Kotlin/Java SDKs (crates.io).
• Governance: Zed + JetBrains co-governance since Oct 2025; public ACP Agent Registry since 2026-01-28 (zed.dev/blog/acp-registry).
• Agents: Claude Code via official claude-agent-acp; Codex via official codex-acp; Gemini CLI native; Copilot CLI native with TCP (copilot --acp --port 8080, GitHub docs); Goose, OpenCode, OpenHands, Junie native. Gaps: Aider, Crush.
• Clients: Zed (reference), JetBrains IDEs, Neovim (CodeCompanion et al), Emacs, Toad, marimo, community VS Code extensions.
• Known criticisms: stdio-only breaks SSH/WSL/remote setups (open Zed bugs #47910, #52254); session persistence optional and fragmented; auth reactive/late-bound; adopting ACP agent-side is an architectural rewrite (harness-side, which is ainb's side, is much lighter).
• ACP vs MCP: complementary layers; the client passes MCP server configs at session/new so the agent connects to tools directly.

5. Buzz features worth porting (full inventory, port calls)

Port call legend: port = lift code/pattern largely as-is; adapt = re-implement the pattern; skip = not worth it for ainb. Effort S/M/L.

Feature	Where in buzz	Infra needed	Call	Effort	Notes
buzz-dev-mcp MCP tool server (shell/read_file/str_replace/todo/view_image + _Stop/_PostCompact hooks + PATH shim + keyfile hygiene)	crates/buzz-dev-mcp	none	port	S-M	Fully standalone; pairs with any ACP/MCP agent ainb spawns
ACP AgentPool + per-channel queue + circuit breaker + steer/interrupt modes	crates/buzz-acp (pool.rs, queue.rs, lib.rs:1027-1136)	none in core loop	adapt	M	The blueprint for ainb's chat agent runtime; use upstream agent-client-protocol crate instead of hand-rolling
Observer side-channel + transcript reducer (final message in chat; thought/tool/plan/permission/cost in side transcript)	kind 24200 + desktop/src/features/agents/lib/agentSessionTranscript.ts	none (pattern)	adapt	M	Best UX pattern in buzz; maps to TUI second pane + Fleet inspector
YAML workflow engine (triggers: message/reaction/schedule/webhook; actions; evalexpr; cron; approval gates)	crates/buzz-workflow (schema.rs, executor.rs, action_sink.rs)	none for schema/executor	port	M	Swap the relay action sink for an ainb sink ("send prompt to session", "broadcast", "notify")
.persona.md persona packs (frontmatter + system prompt, merge/validate, MCP servers, triggers, model)	crates/buzz-persona	none	port	S	Direct fit for per-agent config in chat
Kind-partition contract (content vs aux-overlay vs non-conversational; aux backfilled by reference not time)	desktop/src/shared/constants/kinds.ts	none (design)	adapt	S	Design the ainb message model with this three-way partition from day one
Read-state sync (hierarchical frontier effective(ctx)=max(own,parent), debounced, budgeted)	readStateManager.ts, NIP-RS	none (pattern)	adapt	S	Matters as soon as TUI + macOS + web all show the same chat
buzz-cli agent-ergonomics (JSON stderr errors with retryable, semantic exit codes incl. conflict=5, delivery_unknown never-retryable class, stdin -, errors naming the follow-up command)	crates/buzz-cli/src/error.rs:87-136	none (pattern)	adapt	S	Apply to ainb CLI JSON mode; add the --follow/--wait modes buzz lacks
NIP-42-style challenge auth (~50 lines, transport-agnostic)	crates/buzz-auth/src/nip42.rs:37-86	none	port	S	For any future non-local client auth; URL-bound, replay-safe
NIP-OA / NIP-AA owner-attestation (agent key authorized by owner key, bounded conditions, revocable via owner)	docs/nips/NIP-OA.md, NIP-AA.md	none	adapt	S-M	The identity model for "my agents on my machines" federation
Device pairing with SAS (QR + ECDH + 6-digit safety number + throwaway relay)	crates/buzz-core/src/pairing/, NIP-AB	tiny relay	adapt	M	Only when enrolling devices for multi-machine ainb
Presence/typing/working-signal two-tier model (observer-derived primary, typing fallback; one agent_working module all surfaces read)	agentWorkingSignal.ts:11-45	none (pattern)	adapt	S	Fixes "is it doing anything?" across TUI/Fleet consistently
iroh QUIC endpoint + version-byte postcard framing + fail-closed membership	crates/buzz-relay-mesh/src/{endpoint,wire,membership}.rs	none	hold	M	Only if coordinator-less p2p is ever needed (Sketch B below)
buzz-voice local offline TTS (April Pocket)	crates/buzz-voice	none	optional	S	Agent status announcements; zero infra
sprig multicall binary packaging	crates/sprig	none	optional	S	One binary, argv[0] dispatch, nice for install footprint
Channels/threads/reactions/search/audit substrate	relay + Postgres + Redis	full stack	skip	,	Patterns portable, code inseparable from relay substrate
Git hosting on object storage, huddle audio, media/Blossom, push gateway	relay stack	S3 etc.	skip	,	Out of ainb's product line; CAS-manifest design noted for reference

6. ACP verdict: HYBRID-ADOPT

                       TODAY                          TARGET (hybrid)
┌─────────┐ send-keys ┌──────────┐        ┌─────────┐ fleet/* ┌──────────────┐
│ fleet-  │──────────▶│ tmux pane│        │ TUI /   │────────▶│ hangar daemon│
│ core    │ capture/  │ claude / │        │ Fleet / │         │  chat store  │
│         │◀──────────│ codex    │        │ web     │◀────────│  AgentPool   │
└─────────┘ jsonl tail└──────────┘        └─────────┘ events  └──┬─────────┬─┘
                                                          ACP stdio│         │tmux (kept)
                                                     ┌────────────▼──┐   ┌──▼────────┐
                                                     │ claude-agent- │   │ interactive│
                                                     │ acp / codex-  │   │ tmux       │
                                                     │ acp / gemini  │   │ sessions   │
                                                     └───────────────┘   └───────────┘

Decision: adopt ACP as a new agent transport for chat/broadcast sessions, at the ProviderAdapter seam, inside the hangar daemon. Keep tmux for interactive terminal sessions. Do not replace the hangar plugin protocol or the fleet daemon protocol, ACP is not for those layers.

Rationale:

1. ACP structurally solves what ainb currently scrapes: prompt injection without paste heuristics, streamed output without JSONL tailing, structured permission requests instead of box-drawing detection, cancellation and steering instead of key-mashing. These are precisely the normalize_event/execute/observe_fallback duties of ProviderAdapter (ainb-tui/crates/ainb-fleet-core/src/fleet/provider.rs:149-166).
2. Official adapters exist for both target providers (claude, codex) plus Gemini/Copilot for free, maintained under the protocol org, with a first-party Rust crate. Buzz proves the harness pattern in production; ainb should NOT hand-roll the protocol like buzz did (the upstream crate did not exist when buzz started).
3. What ACP does not replace: the visible tmux session. An ACP agent is a headless subprocess of the harness. ainb's core value (watchable, attachable terminal sessions) stays on tmux; ACP powers the chat-grade sessions where headless is fine or preferable.
4. Wire impact is contained: Provider enum growth + fleet protocol version bump (the enum is on the wire at fleet.rs:91).
5. Two buzz patterns to adopt with it: (a) responses to chat go through the daemon chat store (ainb's "relay"), not raw ACP passthrough to UIs; (b) tool-permission policy is set session-level, with genuinely actionable permission rows in the TUI (buzz renders them read-only, a gap ainb can beat).

Migration sketch (research-only; not scheduled):

1. ainb-acp crate using agent-client-protocol v1.x: spawn adapter, initialize, session/new (pass ainb's MCP servers), session/prompt, reduce session/update into fleet events.
2. Daemon-owned AgentPool (adapt buzz's pool/queue/circuit-breaker; session per chat channel, affinity, rotation).
3. New AcpProviderAdapter implementing the existing ProviderAdapter trait; capability bitset advertises structured send/observe/cancel/steer.
4. Chat store + fleet/message_* methods (see §7); TUI/Fleet/web render from the store.
5. Later: fold AskUserQuestion/attention for ACP sessions into structured session/request_permission handling, retiring scrape heuristics for those sessions.

Risks/trade-offs: ACP sessions are not resumable across daemon restarts CORRECTED 2026-07-31 by spike (research/2026-07-31_acp-resume-steering-spike.md): kill-respawn-load resume PROVEN for claude-agent-acp 0.64.0 and codex-acp 1.1.7, persistence in their own on-disk stores; still optional in spec and unverified for gemini-cli; stdio-only means the agent process must be co-located with the daemon (fine locally; federation handled at the daemon/message layer, not by tunneling ACP); protocol v2 churn upstream (pin v1; buzz squatting v2 is a warning, not a model to copy).

7. Chat surfaces: comparison and build order

Build order: (1) daemon chat bus → (2) Fleet chat + broadcast UI → (3) TUI chat tab. All three share the bus; UIs are thin.

Surface	What exists	What's missing	Effort	Verdict
Daemon-level chat bus	fleet negotiate/subscribe/replay/resync spine; broadcast + receipts; capability gating; hangar/comment_*, inbox, mentions; ainb-hangar-store for persistence	fleet/message_send, fleet/message_list, fleet/thread_*; message table in hangar store; AgentPool wiring (ACP) for agent participants	M	Build first. One protocol, every frontend attaches (TUI, Fleet app, ainb-web). Inherits auth, ordering, replay, receipts for free
Fleet chat + broadcast	Composer (FleetSessionDetailView.swift:87-117), broadcast form with recipient checklist + confirmation (FleetWindowView.swift:430-481), receipts UI	Transcript view (timeline over the bus), thread panel, agent transcript inspector (observer pattern)	M	Second. Broadcast becomes "message to N sessions, replies threaded per session", the fleet-chat-with-broadcast Stevie asked about
TUI chat tab	hangar-tui plugin-as-daemon-client template (ainb-plugin-hangar/src/plugin.rs:821); captures_text for text entry; dormant ClaudeChatComponent UI shell	New plugin + core screen registration (tab set is compile-time: id const, PLUGIN_SCREENS, keybinding); message list + composer in wire-buffer cells	M-L	Third. Highest UI effort (ratatui chat ergonomics); benefits from bus + patterns proven in Fleet first

Design notes carried over from buzz (see §5): clean timeline + side transcript; kind partition (content/aux/non-conversational); slash commands in the TUI (buzz has none, terminal-native gap to exploit); optimistic send with carried local key; message grouping/continuations; one-level threads for v1; agents as members with profiles; sticky "addressed agents" audience per channel.

8. Federation: options and pick

Buzz evidence: relay-to-relay federation does not exist in buzz code (mesh = pod-to-pod, fails closed against foreign relays; buzz/crates/buzz-relay-mesh/src/membership.rs:36-42,90-102). What is portable is identity (keypair, NIP-42 challenge, NIP-OA/NIP-AA owner→agent attestation) and the pairing UX (QR + ECDH + 6-digit SAS + stateless throwaway relay; buzz/crates/buzz-core/src/pairing/). Their compute mesh (iroh QUIC, NIP-51 discovery, dual-signature endpoint binding, fail-closed roster intersection) is the best small-scale authenticated-peer-discovery reference (~300 lines of pattern).

Candidate architectures:

A) Tiny signed-event hub               B) Hubless iroh QUIC p2p
┌──────┐ wss ┌─────────┐ wss ┌──────┐  ┌──────┐ QUIC(ALPN ainb/1) ┌──────┐
│ainb 1│────▶│hub+sqlite│◀───│ainb 2│  │ainb A│═══════════════════│ainb B│
└──────┘     └─────────┘     └──────┘  └──┬───┘                   └──┬───┘
  signed events, NIP-42 challenge         └──▶ rendezvous blob ◀─────┘
                                               (signed peer records)
C) Tailscale/SSH + existing daemon (PICK)
┌─────────┐  tailnet (WireGuard) or ssh -L   ┌─────────────┐
│ ainb TUI│─────────────────────────────────▶│hangar daemon│
│ laptop  │  existing fleet protocol,        │ devbox      │
└─────────┘  unchanged                       └─────────────┘

Pick: C now. The daemon protocol + ainb-web already carry everything; Tailscale supplies identity, enrollment, revocation, NAT traversal and encryption, the exact list A and B rebuild by hand. Threat model check: "Stevie's laptop ↔ Stevie's devbox" has no untrusted party, so buzz's signature layers buy nothing yet. Sequencing: adopt the NIP-42 challenge (50 lines) the moment a second person's machine joins; NIP-OA-style owner→agent attestation when agents get their own keys; reach for B (iroh) only if coordinator-less p2p becomes a requirement. Buzz's own history endorses this ordering, thorough identity layer, still no federation, and both times they went p2p they kept a central bootstrap anyway.

Concrete near-term enablers already in-tree: ainb-web non-loopback bind + bearer token (docs describe tailnet usage, docs/tui/web.md:1-13); FleetTransport seam for a remote-peer transport as a 4th bridge impl; hangar.sock → optionally also listen on a tailnet TCP port behind the same token auth (needs a hardening pass).

9. Cross-cutting cautions

• Every chat surface built above the scrape layer inherits the tmux ceiling until the ACP adapter lands; sequencing chat-bus-first is fine because agent participants can start as ACP sessions from day one (chat channels don't need tmux at all).
• The second, unhardened send path (ainb-core/src/cli/run.rs:417-430: bare send-keys + C-m, no -l, no --, no verify) violates the fleet-core "ONE verified send path" invariant, worth fixing regardless of this research.
• Fleet Provider enum (Claude | Codex | Unknown) is on the wire; growing it is a protocol-version event, batch it with the ACP work.
• Buzz README/screenshots oversell in places (e.g. "frame-anchored media comments" not found in code; VISION docs vs code drift on NIP-34 issues), treat buzz VISION docs as direction, code as truth.

Code References

ainb (branch f/buzz):

• ainb-tui/crates/ainb-fleet-core/src/fleet/provider.rs:149-166, ProviderAdapter seam (ACP attachment point)
• ainb-tui/crates/ainb-fleet-core/src/fleet/send/tmux.rs:44-46,84-104, current send path + paste-retry ceiling
• ainb-tui/crates/ainb-fleet-core/src/fleet/read/jsonl_tail.rs:16-49, JSONL transcript scraping
• ainb-tui/crates/ainb-hangar-proto/src/fleet.rs:290-352,624-663,727-742, negotiate/replay, receipts, broadcast params
• ainb-tui/crates/ainb-hangar-daemon/src/rpc/mod.rs:210-222, socket + auth
• apps/ainb-fleet-macos/Sources/FleetUI/FleetWindowView.swift:430-481, existing broadcast form
• ainb-tui/crates/ainb-plugin-hangar/src/plugin.rs:821, plugin-as-daemon-client template
• ainb-tui/crates/ainb-web/src/config.rs:97-136, remote bind policy
• ainb-tui/crates/ainb-core/src/fleet/bridge/relay.rs:1-30, FleetTransport seam
• ainb-tui/crates/ainb-core/src/components/claude_chat.rs:14, dormant chat UI shell

buzz @ 39ce3df (session scratchpad clone):

• crates/buzz-acp/src/{acp.rs,pool.rs,queue.rs,config.rs}, ACP harness (pool 556-596, queue 92-136, breaker lib.rs:1027-1136)
• crates/buzz-dev-mcp/src/{lib.rs,shim.rs}, standalone MCP tool server + shim/keyfile hygiene
• crates/buzz-workflow/src/{schema.rs,executor.rs,action_sink.rs}, liftable workflow engine
• crates/buzz-persona/src/persona.rs:101-169, persona pack format
• crates/buzz-auth/src/nip42.rs:37-86, challenge auth
• docs/nips/NIP-OA.md, docs/nips/NIP-AA.md, owner→agent attestation
• crates/buzz-core/src/pairing/, SAS device pairing
• crates/buzz-relay-mesh/src/{endpoint.rs,wire.rs,membership.rs}, iroh QUIC mesh (intra-deployment)
• desktop/src/shared/constants/kinds.ts, kind partition contract
• desktop/src/features/agents/lib/agentSessionTranscript.ts, ACP-update transcript reducer
• crates/buzz-cli/src/error.rs:87-136, agent-ergonomic CLI error contract

External:

• https://agentclientprotocol.com/overview/architecture, spec, transport, MCP composition
• https://crates.io/crates/agent-client-protocol, Rust SDK v1.6.0
• https://github.com/agentclientprotocol/claude-agent-acp · https://github.com/agentclientprotocol/codex-acp, official adapters
• https://docs.github.com/en/copilot/reference/copilot-cli-reference/acp-server, Copilot ACP TCP mode
• https://zed.dev/blog/acp-registry · https://zed.dev/blog/jetbrains-on-acp, governance/registry
• External Agents installed via ACP Registry do not work on remote Zed Server (Windows → Ubuntu via SSH) or WSL zed-industries/zed#47910 · /52254, remote ACP limitations

Recommendations

1. Adopt ACP at the ProviderAdapter seam (hybrid): new ainb-acp crate on the upstream Rust SDK, daemon-owned AgentPool adapted from buzz, tmux retained for interactive sessions.
2. Build the daemon chat bus first (fleet/message_* + message model in hangar store), then Fleet chat/broadcast UI, then the TUI chat tab, one bus, three thin surfaces.
3. Steal buzz's UX contract: final-message-only timeline + side transcript from ACP updates; kind partition; read-state frontier; actionable permission rows (improving on buzz).
4. Federate via Tailscale/SSH over the existing daemon now; add NIP-42-style challenge + NIP-OA-style agent attestation only when a second person joins; keep iroh p2p in the back pocket.
5. Quick wins independent of the big three: port buzz-dev-mcp pattern as ainb's agent tool server; .persona.md support; buzz-cli error/exit-code contract for ainb --format json; fix the unhardened run.rs send path.

Open Questions

• ACP session persistence: which adapters support session/load today, and what does chat-session resume look like across daemon restarts? (Spec makes it optional; needs a per-adapter test matrix.)
• Steering support matrix: _session/steering is an extension, verify claude-agent-acp/codex-acp behavior before promising broadcast-steer semantics.
• Message model shape in ainb-hangar-store (SQLite): adopt buzz's content/aux/non-conversational partition directly, or simplify to messages+receipts for v1?
• Whether the Fleet protocol version bump (Provider enum growth) should also carry the fleet/message_* family in one break.
• buzz job-request kinds (43001-43006) ride generic ingest with no dedicated dispatcher, is there a cleaner job-protocol pattern worth defining for ainb squads, or is comment-@mention dispatch (Multica conclusion) sufficient?

[stevengonsalvez]

Spike: ACP session resume and steering, per-adapter probe results

Date: 2026-07-31
Branch: f/buzz
Answers open questions 1 and 2 of research/2026-07-31_14-56-19_buzz-acp-port.md:229-230
Status: 2 of 3 adapters verified end to end on live wire; gemini-cli blocked at session/new by missing credentials (source-read only)

Method

Each adapter was installed locally and driven by a purpose-built Node client speaking newline-delimited JSON-RPC 2.0 over piped stdio, with every byte in both directions timestamped into a wire.log; the client answered any agent-to-client request with -32601 so the agent could never hang.
Scenarios per adapter: initialize capability read, session/new, real session/prompt turns, SIGKILL of the adapter process followed by a fresh process doing session/load on the same sessionId, _session/steering in-flight and idle, session/list, and a deliberately bogus method. Empirical results were cross-checked against the shipped (unminified) adapter source.

Support matrix

Adapter	Version	loadSession cap	session/load behaviour	session/list	Steering flags	Unknown-method behaviour	Resume verified e2e	Auth situation
@agentclientprotocol/claude-agent-acp	0.64.0	true	Works with a real sessionId, in-process and after a hard process kill. Replays history as session/update notifications (2 observed) before returning. Reply echoes the same sessionId. Malformed non-UUID id leaks the CLI error verbatim as -32603	Yes, advertised and working. Returns {sessions:[{sessionId,cwd,title,updatedAt}]}, filtered by cwd, empty for a session with no messages	Present: top-level _meta.steering.supported = true on the initialize result (NOT inside agentCapabilities). Also agentCapabilities._meta.claudeCode.promptQueueing = true	Proper -32601, offending method echoed in data.method	Yes. Codeword survived SIGKILL plus fresh-process load	Not blocked. authMethods: [], ambient ~/.claude/.credentials.json picked up implicitly, real turns completed with stopReason: end_turn
@agentclientprotocol/codex-acp	1.1.7	true	Works only once a rollout is persisted (at least one turn). Three distinct failures, all -32603 with free-text data.details: no rollout found for thread id X (fresh session AND fabricated id, indistinguishable except by the echoed id), and session X is archived after session/delete. Success result does NOT echo sessionId. Replays history during the call (7 notifications for a 1-turn session)	Yes, advertised and working. Returns {sessions:[...],nextCursor} with auto-derived title; optional cwd filter	Present: initialize result has _meta.steering.supported = true. Extension is _session/steering; bundle also defines _codex/session/goal_control	Proper -32601 for _test/bogus, totally/madeup, goose/customNotifications, _codex/bogus. Unknown notifications silently ignored (spec-correct)	Yes. Magic word survived SIGKILL plus fresh-process load, at 18k cached input tokens for a 1-turn reload	Not blocked. Pre-existing ~/.codex/auth.json. initialize is genuinely auth-free; every session/* method calls an internal checkAuthorization() per bundle source
gemini-cli	0.53.0	true	Implemented and dispatched, but auth-gated: fabricated id returns -32000 "Authentication required", NOT -32601. Real path unreachable. Source shows a genuine disk-backed resume via SessionSelector.resolveSession then geminiClient.resumeChat then streamHistory (bundle gemini-7M47OEXS.js:15092). Unverified on wire	Absent. -32601. Present in the bundled ACP name table only; SessionSelector.listSessions() exists internally but is not exposed over ACP	Absent. No _meta at the top level of initialize and none in agentCapabilities. _session/steering returns -32601. An internal experimental.modelSteering prompt-injection path exists but is not wired to ACP	Proper -32601, offending method echoed in data.method	No, blocked by auth	Blocked. No ~/.gemini, no GEMINI_API_KEY/GOOGLE_API_KEY, no ADC. authenticate with oauth-personal needs an interactive browser and was not attempted (credential acquisition)

Secondary capability read

Fact	claude-agent-acp	codex-acp	gemini-cli
Negotiated protocolVersion	1	1	1 (verified clamping: client sent 99, agent replied 1)
Other sessionCapabilities advertised	additionalDirectories, close, delete, fork, list, resume	additionalDirectories, close, delete, list, resume	none
promptCapabilities	image, embeddedContext	image, embeddedContext	image, audio, embeddedContext
mcpCapabilities	http, sse	http (acp false, sse false)	http, sse
Default session mode observed	bypassPermissions (inherited from ambient state, not requested)	agent (read+edit+run)	not reachable
Model/mode state returned inline at session/new	yes (modes + several KB of configOptions)	yes (models with 38 entries, modes, configOptions)	not reachable
Agent-to-client requests observed across all runs	zero	zero	zero

Steering outcomes actually observed

Adapter	In-flight turn	Idle session	Idle with opt-in	Error shapes
claude-agent-acp	{"outcome":"injected"}, pushed onto the same SDK streaming input at priority now, pre-empting the current generation; the steered reply streams via session/update, not via the steer response	{"outcome":"startedNewTurn"}, and the adapter fires a detached prompt() whose result the client never receives	request _meta {"steering":{"idleBehavior":"promptRequired"}} gives {"outcome":"promptRequired","reason":"noRunningTurn"} and sends nothing	bad idleBehavior: -32602 "Invalid params: unsupported steering idleBehavior". Unknown well-formed UUID: -32603 with details: "Session not found"
codex-acp	{"outcome":"injected"}, NON-cancelling: the original turn continued to stopReason: end_turn. Proof: prompt "count 1 to 10" plus steer "append PINEAPPLE" produced ...10PINEAPPLE	{"outcome":"startedNewTurn"}	not offered	param is prompt (array of content blocks), not content; wrong shape gives -32602 with a zod _errors tree
gemini-cli	no ACP steering surface at all	n/a	n/a	-32601

Timeline caveat on the claude-agent-acp steer run: the 6 s mid-turn delay in the driver was too long, so the probe labelled steer-midturn actually exercised the idle path and the probe labelled promptRequired hit the in-flight path. Both outcomes are genuine and match the adapter source (dist/acp-agent.js:915-975); only the labels in results-steer.json are off by one state.

Open questions answered

Q1 (line 229): which adapters support session/load today, and what does chat-session resume look like across daemon restarts?
Answered, and the answer overturns the doc's risk line. research/2026-07-31_14-56-19_buzz-acp-port.md:139 says "ACP sessions are not resumable across daemon restarts". That is false for claude-agent-acp and codex-acp at the versions probed. Both persist to their own on-disk session stores (the Claude Code session store, and codex rollouts under ~/.codex), not to adapter process memory, so a SIGKILL of the adapter and a fresh process reloading the same sessionId recovers full conversational context. Both were proven with a secret-word round trip across a real process kill. Gemini-cli's resume is implemented and disk-backed per source read but is unverified on wire (blocked by credentials).

Q2 (line 230): verify claude-agent-acp/codex-acp steering behaviour before promising broadcast-steer semantics.
Answered. Steering can be promised for claude-agent-acp and codex-acp: both advertise _meta.steering.supported = true at initialize, both implement _session/steering, both return an outcome discriminator, and injection was proven to reach the model in both. It cannot be promised for gemini-cli today. Broadcast-steer therefore has to be a per-adapter capability, not a fleet-wide guarantee.

Implications for the ainb chat-bus plan

Resume strategy the daemon must own

• Do not build a client-side transcript replay for resume. For claude-agent-acp and codex-acp the daemon only needs to persist the (provider, sessionId, cwd) tuple; the adapter's own store holds the history and replays it as session/update notifications during the session/load call. The daemon's job is durable sessionId storage plus a rehydration path, not a message-log shadow copy.
• The session/update replay arrives before the session/load reply. Any AcpProviderAdapter must have its notification handler live and routing to the right session before it issues session/load, otherwise the entire replayed history is dropped on the floor. This is the single most likely implementation bug in the port.
• cwd is part of the session key. Gemini scopes session files by a project identifier derived from the target dir (source-confirmed), and both working adapters accept a cwd filter on session/list. Store cwd alongside the sessionId and pass the same value on load.
• Session config does NOT survive session/load on codex-acp (measured: currentModelId reverted to the default and mode reverted to agent). The daemon must re-apply model, mode and reasoning effort after every load. Treat post-load config re-application as a mandatory step of the rehydrate routine, not an optimisation.
• Pin the permission mode explicitly. claude-agent-acp's session/new came back with currentModeId: bypassPermissions inherited from ambient state, and as a direct consequence zero agent-to-client requests fired across every run (no session/request_permission, no fs/*, no terminal/*); stderr confirmed canUseTool will not be invoked. If ainb wants the actionable-permission rows the research doc plans for, it must pin the mode at session/new or immediately via session/set_mode. Trusting the default silently disables the whole permission UX.
• "Unknown session" is not typeable on codex-acp. A fabricated id and a real-but-turnless session both return -32603 with a free-text data.details, distinguishable only by string-matching no rollout found vs is archived. Wrap that string matching in exactly one place in the adapter and treat it as a known-brittle seam.
• session/delete on codex-acp is a soft archive, and there is no ACP method to unarchive (only the codex unarchive CLI). From the ACP surface, treat delete as irreversible. session/close returns {} and does not invalidate the session (a later session/load in the same process succeeded); it only releases in-process resources.
• Session fork is advertised by claude-agent-acp (sessionCapabilities.fork) and is directly interesting for broadcast/branching, but is untested by this spike.

Whether steering can be promised, per adapter

• claude-agent-acp: yes, with a required guard. The idle path fires a detached prompt() whose result the client never receives, which is a ghost turn from the harness's point of view. ainb must always send the request _meta {"steering":{"idleBehavior":"promptRequired"}} opt-in so an idle steer degrades into an explicit promptRequired outcome instead of an untracked turn.
• codex-acp: yes. Injection is non-cancelling and the original turn completes normally. Param name is prompt (array of content blocks). No idle opt-in is offered, so an idle steer will start a turn; branch on the returned outcome rather than trying to track in-flight state client-side. The outcome discriminator means one method covers both steer-and-prompt.
• gemini-cli: no. Fall back to queueing or to a plain session/prompt. Broadcast-steer must be advertised in ainb's capability bitset per adapter, and the UI must not offer steer for adapters that lack it.

The codex-acp {} false-success hazard and the capability-gating rule it forces

• The research doc's claim at research/2026-07-31_14-56-19_buzz-acp-port.md:57, that codex-acp answers unknown methods with {} success (buzz's stated reason for capability-gating Steer), is not true at codex-acp 1.1.7. Verbatim reply to a bogus method: {"jsonrpc":"2.0","id":7,"error":{"code":-32601,"message":"\"Method not found\": _test/bogus","data":{"method":"_test/bogus"}}}. Same -32601 for the underscore-extension namespace, so _-prefixed methods are not a silent-success path. All three adapters return a well-formed -32601 with the offending method echoed in data.method.
• Caveat, stated honestly: this spike cannot speak to older codex-acp versions where buzz may genuinely have observed {}. The rule that follows is to assert a version floor, not to assume good behaviour.
• Concrete gating rule for AcpProviderAdapter: gate on the declared flag first (initialize result _meta.steering.supported), fall back to method probing only when the flag is absent, and record the adapter name plus version from agentInfo so a floor can be enforced. Never infer a capability from a bare success reply.
• Error-code taxonomy to encode once in the adapter, valid across all three probed adapters: -32601 means the method is genuinely absent; -32602 means the method exists but params are wrong (this is how you positively confirm an extension exists without valid args); -32603 plus free-text data.details means a business-logic failure; -32000 on gemini-cli specifically means the method exists and the auth gate fired first. That last distinction makes "implemented but unauthenticated" separable from "not implemented" during capability discovery.
• A real trap that -32601 probing does NOT catch: session/set_config_option takes configId, not optionId. The wrong name returns -32602 and the run silently continues on the default model. Param-shape errors are only visible if the adapter checks every reply, so the ACP client must not fire-and-forget any request.

Interop hazard specific to gemini-cli

• authenticate with methodId: oauth-personal writes raw ANSI escape sequences and human prose to stdout, i.e. onto the JSON-RPC channel. First polluted line, cat -v: ^[[?1049h^[[2J^[[H^[[?1006l^[[?1002l^[[<u^[[?7hPlease visit the following URL to authorize the application: followed by a bare accounts.google.com URL. The clean (non-auth) run produced zero non-JSON stdout lines and zero stderr bytes, so the pollution is specific to the interactive auth flow. Recommendation: ainb must never call authenticate for gemini-cli, and should require pre-provisioned credentials instead; the line reader should still tolerate and skip non-JSON lines defensively.

Known gaps in this spike

• session/load with a well-formed but nonexistent UUID on claude-agent-acp: untested. Only a malformed non-UUID string was tried. Steering with a nonexistent well-formed UUID gave -32603 "Session not found", so load probably behaves similarly, but that is inference, not measurement.
• Permission-request handling is unverified on every adapter. Zero agent-to-client requests were issued across all runs because no prompt exercised a gated tool and claude-agent-acp ran in bypassPermissions. Needs a dedicated tool-using prompt.
• Advertised but untested: session/fork, session/resume, providers/*, mcp/message, nes/*, authentication/* on codex-acp; session/fork, session/resume, session/close, session/delete on claude-agent-acp; gemini-cli's entire post-auth surface including session/prompt, session/update streaming and session/request_permission.
• Gemini's session/fork, session/resume and session/close appear as schema constants in the bundle but were not probed; only session/list was empirically confirmed absent. Assume all four are absent.

Raw evidence

All paths are absolute. Every wire.log contains ISO-timestamped raw bytes in both directions.

claude-agent-acp

Path
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/wire.log
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/probe.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/results-probe.json
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/results-prompt.json
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/results-resume.json
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/results-steer.json
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/results-steer2.json
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/claude-agent-acp/state.json

Source corroboration (readable JS with doc comments): node_modules/@agentclientprotocol/claude-agent-acp/dist/acp-agent.js:637 (loadSession: true), :660 (the _meta.steering.supported advertisement), :56 (const STEER_METHOD = "_session/steering"), :915-975 (the three-branch steer() implementation matching the three observed outcomes), :6055-6057 (session.load / session.list wiring).

codex-acp

Path
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/wire.log
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/probe.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/run1-capabilities.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/run2-prompt-and-steer.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/run3-respawn-load.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/run4-edge-cases.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/session-id.txt
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/codex-acp/node_modules/@agentclientprotocol/codex-acp/dist/index.js

The bundle is 1.1 MB unminified and greppable (AGENT_METHODS table, agentRequestSpecs, AcpExtensions.ts constants); it was used to cross-check every empirical result. codex-acp bundles @openai/codex and drives a codex app-server child, so it is a shim over codex's own app-server protocol rather than a reimplementation.

gemini-cli

Path
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/gemini-cli/wire.log
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/gemini-cli/wire-protocolversion.log
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/gemini-cli/probe.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/gemini-cli/pv.mjs
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/gemini-cli/help.log
/tmp/claude-1000/-home-claude--agents-in-a-box-worktrees-by-name-agents-in-a-box--f-buzz--19533eb1/1bf5746e-45a7-4119-8b64-a3c5f953ccfb/scratchpad/acp-spike/gemini-cli/npx-install.log

Source references: bundle/gemini-7M47OEXS.js:15092 (loadSession implementation), bundle/chunk-F3VE7C53.js:253130,253264 (Storage.getProjectTempDir, listProjectChatFiles, i.e. the cwd-scoped session store at ~/.gemini/tmp/<projectIdentifier>/chats/*.json), bundle/chunk-W5BZ47UJ.js:10115 (SessionSelector.listSessions, internal only), bundle/chunk-F3VE7C53.js (USER_STEERING_INSTRUCTION, in-app only). To close the gemini gap, re-run probe.mjs with GEMINI_API_KEY set in the child env.

Install notes

Adapter	Command	Result
claude-agent-acp	npm i @agentclientprotocol/claude-agent-acp	0.64.0, 104 packages, 10 s. Binary node_modules/.bin/claude-agent-acp, plain stdio ndjson, no flags. Use the @agentclientprotocol org package; @zed-industries/claude-code-acp is at 0.16.2 and far behind
codex-acp	npm i @agentclientprotocol/codex-acp	1.1.7, 19 packages, 9 s. Binary node_modules/.bin/codex-acp
gemini-cli	npx -y @google/gemini-cli	0.53.0, roughly 2 min. Flag is --acp; --experimental-acp still accepted but marked deprecated

Whole codex-acp spike ran about 4 minutes wall clock and roughly 37k tokens of codex usage across 3 prompts. No credential values were read, printed or logged for any adapter.