# Infrastructure Inventory for poc-agent Transition

What Claude Code provides that poc-agent needs to replicate.

**Source of truth for current infrastructure:**
[~/.claude/memory/poc-architecture.md] — the full wiring diagram with
every script, state file, and data flow. This file focuses on the
porting gap: what poc-agent has, what it needs, and how each bash
prototype maps to a Rust equivalent.

## What poc-agent has (working, v0.3)

- [x] CLAUDE.md loading (walk cwd → git root)
- [x] Memory file loading (project dir discovery, 7 identity files)
- [x] 7 tools: read, write, edit, bash (async+timeout), grep, glob
- [x] SSE streaming with real-time output
- [x] Session persistence (save/restore JSON)
- [x] TUI: split-pane (autonomous / conversation / tool activity / status)
- [x] DMN state machine: Engaged → Working → Foraging → Resting
- [x] Compaction: token counting, pre-compaction dump prompt, context
      truncation + reload from memory files
- [x] POC_SYSTEM_PROMPT_FILE for bootstrap test

## Bash → Rust mapping

Each row is a Claude Code bash prototype and where it lands in poc-agent.

| Bash prototype | What it does | poc-agent target | Status |
|---------------|-------------|-----------------|--------|
| **Hooks** | | | |
| load-memory.sh | Load ~15-20 memory files at session start, priority-ordered | config.rs memory loading | **Done** — matches load-memory.sh priority ordering + people/ glob |
| check-context-usage.sh | Token monitoring (130K threshold), compaction warning, Telegram inbox on user prompt, clear idle timer | Compaction already built; Telegram delivery not yet | **Partial** |
| memory-search.sh | Ambient memory retrieval: extract terms from user prompt + self-prime, search memory-weights, inject tiered results, dedup per session, anti-injection cookie, context budget | Agent turn loop: pre-search before model call | **Not started** |
| self-prime.sh | Extract top terms from last response for next search | Post-response hook in agent loop | **Not started** |
| record-user-message-time.sh | Timestamp for idle timer | Built into agent loop (DMN state transitions) | **Done** — implicit in DMN |
| check-attention.sh | Deliver ~/bin/hey nudges, rate-limited notifications (2min), scratch consolidation pressure (50/80 lines) | Between-tool-call check | **Not started** |
| check-notifications.sh | Surface unified notification queue on user prompt | Pre-turn notification check | **Not started** |
| notify-done.sh | Desktop notification (OSC 777 via tmux), write last-response-time, respect sleep file | Post-response: notification + DMN timestamp | **Not started** |
| daily-commit.sh | Cron: daily git snapshot of ~/.claude/ | External (stays as cron) | **N/A** — not an agent concern |
| memory-snapshot.sh | Git snapshot before/after consolidation/dreams | Shell out via bash tool | **N/A** — called explicitly |
| **Idle timer** | | | |
| idle-timer.sh | Three modes: active pause (5min), genuinely idle (20min), sleep wake. Keyboard idle, IRC ambient, dream nudges, notification digest | DMN state machine + event sources | **Partial** — DMN exists, needs: keyboard idle signal, IRC ambient, dream state awareness, notification integration |
| keyboard-idle-push.sh | Push keyboard idle from Kent's laptop via ssh | Read keyboard-idle-since file (or future: signal channel) | **Not started** |
| **Dream infrastructure** | | | |
| dream-start.sh | Enter dreaming: set flag, compact, wander prompt | DMN Dreaming state + compaction trigger | **Not started** |
| dream-end.sh | Exit dreaming: capture to dream-log.jsonl, snapshot, decay | DMN state transition + structured output | **Not started** |
| dream-loop.sh | Sustained dreaming: timed cycles, fresh anchors, nudge rotation | DMN Dreaming with built-in cycle timing | **Not started** |
| dream-seeds.sh | Find unconsolidated memories | Shell out to memory-weights | **N/A** — called explicitly |
| **Communication** | | | |
| irc_client.py | Persistent OFTC connection, log messages, detect mentions, inject via tmux when Kent AFK | Async IRC channel in tokio event loop | **Not started** |
| irc_send.sh | Send to IRC via file queue, auto-split at 400 chars | IRC channel send method | **Not started** |
| poll.sh | Telegram long-polling daemon | Async Telegram channel | **Not started** |
| send.sh | Send text/file/audio to Kent via Telegram | Telegram channel send method (or shell out) | **Not started** |
| **External tools** | | | |
| memory-weights | Rust binary: search, init, decay, used, wrong, gap, wander, graph, orphans | Call as library or binary | **Available** — already Rust |
| conversation_indexer.py | Extract, score, link conversation transcripts | Shell out via bash tool | **N/A** — called explicitly |
| pick_task.py | Weighted random task picker | Shell out or rewrite | **N/A** — called explicitly |
| ci_dashboard.py | CI status | Shell out | **N/A** |
| emotion_capture.py | Emotional state logging | Shell out | **N/A** |
| **State management** | | | |
| Flag files (sleep, quiet, dream-state, etc.) | Mode signaling via file presence/contents | Proper state machine transitions (DMN enum) | **Partial** — DMN has 4 states, needs: Stored, Dreaming, Consolidating, Quiet |
| notifications/queue | Unified notification queue (IRC, Telegram write; hooks read) | Typed event channel (mpsc) | **Not started** |

## Priority order for porting

What matters most for daily use, not theoretical completeness:

1. ~~**Full memory loading**~~ — DONE. config.rs now matches
   load-memory.sh's full priority list: where-am-i, identity,
   interests, default-mode-network, people/ glob, etc.

2. **Notification routing** — unified event channel replacing the
   file-based queue. IRC mentions, Telegram messages, attention nudges
   all arrive as typed events. The DMN decides when to surface them
   based on current state.

3. **Memory-search integration** — ambient retrieval on every turn.
   Extract terms from user message + previous response, call
   memory-weights search, inject results. The self-priming loop.

4. **DMN state expansion** — add Stored (voluntary rest with wake
   conditions), Dreaming (cycle timing, consolidation-first), Quiet
   (suppress notifications). See design-concepts.md for Stored design.

5. **Communication channels** — IRC and Telegram as async streams in
   the tokio event loop. Replace file-based send/receive with proper
   async I/O. The daemons (irc_client.py, poll.sh) become Rust tasks.

6. **Keyboard idle / sensory signals** — read keyboard-idle-since,
   eventually build toward the signal landscape in design-concepts.md.

Items marked **N/A** above stay as external tools called via bash.
memory-weights is the one binary that could become a library dependency
instead.

## Gaps identified in poc-architecture.md §5

These affect the *bash* infrastructure too, not just poc-agent:

- **Quiet mode** — no notification suppression during deep work
- **Consolidation as session mode** — no "I'm consolidating" state
  that other infrastructure respects
- **Unified session state** — mode inferred from scattered flag files
  instead of queried from one place
- **Self-model lag** — no automatic capability scan for new tools/scripts