Overview

The Terminal Memory Bridge connects QuoxTerminal to the Memory System. Every terminal session silently extracts structured data from your command output (hosts, IPs, services, errors) and stores them as entities in your knowledge graph.

This creates a compounding flywheel: the more you use the terminal, the more your AI knows about your infrastructure. When you ask a question, the AI already has context about your hosts, past errors, and their resolutions.

QuoxTerminal is available in two editions: as a native desktop app (Tauri + Rust, macOS/Linux) with local PTY and direct SSH, and as a web plugin in the QuoxCORE dashboard. Terminal Memory works with both editions. The desktop app includes a local memory bridge with entity extraction, error tracking, session lifecycle, and a Memory Activity Feed built into the AI chat sidebar.

What gets extracted

Entity types

The bridge automatically detects and stores these entity types from terminal output:

Entity Type	Examples	How Detected
`host`	nw-web-01, nw-monitor-01, nw-hv-03	SSH connections, hostnames in output
`ip`	10.20.0.101, 10.20.0.1	IP address patterns in output
`service`	nginx, postgres, redis	Service names in systemctl, docker output
`container`	nginx-proxy, quox-api	Docker container names
`port`	:3000, :8080, :443	Port numbers in network output

Entities are stored with a terminal source tag and timestamp, so the system knows where and when each piece of knowledge was learned.

Error patterns

Terminal errors are detected by the error detection system and recorded as error entities. Each error includes the error type, the original error line, and the host where it occurred.

When you ask the AI to explain an error, the explanation is stored as an error resolution , creating a permanent record of “this error means this, and here’s how to fix it.” This is a premium feature requiring QuoxMEMORY.

Session tracking

Every terminal session is tracked with its host, mode (local or SSH), connect time, and disconnect time. This builds a session history that the Host Knowledge Card uses to show accumulated knowledge when you reconnect.

Free vs premium

Basic memory features work out of the box with QuoxTerminal. Premium features require the Advanced Memory plugin.

Capability	Free	Premium
Entity extraction (hosts, IPs, services, containers)	✓	✓
Error detection and tracking	✓	✓
Session history and metrics	✓	✓
Memory Activity Feed (real-time visibility)	✓	✓
Host Knowledge Card (on connect)	✓	✓
Error resolution memory	—	✓
Command pattern learning	—	✓
Working set focus tracking	—	✓
Open loop creation for unresolved errors	—	✓

Memory activity feed

The Memory Activity Feed is a collapsible panel in the terminal chat sidebar that shows memory events in real-time. As you work in the terminal, you’ll see entities being learned, errors tracked, and resolutions stored, making the invisible visible.

What you’ll see:

Green dots — entities extracted (hosts, IPs, services)
Blue dots — session events (connect, disconnect)
Red dots — errors detected
Purple dots — premium events (resolutions, commands, focus)
Amber text — upgrade prompts when free-tier hits a premium feature

The feed is collapsed by default and shows an event count badge. Click to expand. State persists per workspace across page refreshes.

Host knowledge card

When you connect to a host that the system already knows about, a knowledge card appears between the pane header and the terminal. It shows:

Number of previous sessions on this host
Known services and containers running on the host
The most recent error encountered on this host (with relative time)

The card is dismissible. Click the X to hide it for the current session. It reappears on the next connection, giving you a quick context refresher. First-time connections to unknown hosts show nothing.

How it works

Data flow

The terminal memory bridge sits between your terminal and the memory system:

Terminal output flows through the ANSI stripper and into the bridge
Entity extraction detects hosts, IPs, services, containers, and ports
Entities are stored in the knowledge graph via the Memory Manager
Events are emitted to the Memory Activity Feed for real-time display
AI context injection — next time you ask a question, the AI receives entity context

Error detection runs in parallel. When the error detection system finds an error, the bridge stores an error entity and (for premium users) creates an open loop in Working Set Memory.

Desktop app: In the native desktop edition, session lifecycle (connect/disconnect), entity extraction, and error recording are wired directly into the terminal panes. Data is stored locally via the Tauri store. No collector or cloud connection required. When a collector is available, the bridge can optionally relay to it for cross-device sync.

Event types

The bridge emits these event types through the Memory Activity Emitter:

Event	When	Tier
`session_start`	Terminal connects to a host	Free
`session_end`	Terminal disconnects	Free
`entity_stored`	Host, IP, service, etc. detected in output	Free
`error_tracked`	Terminal error detected	Free
`resolution_stored`	AI explanation stored as learned memory	Premium
`command_recorded`	Command execution recorded as decision	Premium
`focus_updated`	Workspace/tab change updates WSM focus	Premium
`upgrade_blocked`	Free user hits a premium feature	Free

Integration with QuoxMEMORY

QuoxTerminal and QuoxMEMORY are designed to complement each other:

Terminal alone: Entity extraction, error tracking, and session history work out of the box. Your AI builds a basic infrastructure map from your sessions.
Memory alone: Full memory system with episodic, semantic, entity, and working set memory. But without terminal data, the richest source of infrastructure knowledge is missing.
Both together: Terminal feeds Memory. Memory enriches AI context. AI gives better answers. You run more commands. More data flows to Memory. A compounding flywheel where every session makes the next one smarter.