tweak agent term scrollback, bump vers

bound agent terminal scrollback memory, for one term could hold a whole 32MB of stuff beforehand
backpressure terminal output without dropping bytes
2026-07-21 05:47:50 +07:00 · 2026-07-21 04:48:05 +07:00 · 2026-07-21 01:06:48 +07:00 · 2026-07-21 01:01:09 +07:00 · 2026-07-21 00:58:02 +07:00 · 2026-07-21 00:34:29 +07:00
87 changed files with 9483 additions and 3142 deletions
@@ -18,6 +18,8 @@ jobs:
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          submodules: recursive
      - name: Ensure toolchain and targets
        shell: pwsh
@@ -11,6 +11,8 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          submodules: recursive
      - uses: dtolnay/rust-toolchain@stable
        with:
@@ -16,6 +16,8 @@ jobs:
    steps:
      - name: Checkout
        uses: actions/checkout@v4
        with:
          submodules: recursive
      - uses: dtolnay/rust-toolchain@stable
        with:
@@ -0,0 +1,3 @@
 [submodule "vendor/vt100"]
 	path = vendor/vt100
 	url = https://github.com/ldlda/vt100-rust-1
@@ -0,0 +1,146 @@
 # Wakey
 Wakey models devices discovered on a local network and the control-plane view used to wake and manage them across agents.
 ## Language
 **Device**:
 An operator-facing aggregate that represents one discovered network identity candidate.
 _Avoid_: Host, machine, route
 **Device Summary**:
 The derived names, MACs, IPs, and presence shown on a device aggregate.
 _Avoid_: Source of truth, route data
 **Endpoint**:
 One observed network contact point for a device, including the agent/source, optional MAC, optional IP, presence, and observation time.
 _Avoid_: Raw observation, route, IP row
 **Endpoint Source**:
 The typed origin of an endpoint, such as neighbor data, DHCP lease data, or a hotplug hook.
 _Avoid_: String kind, source label
 **Observation Fact**:
 Debug evidence copied from local observation inputs before it is interpreted into endpoints.
 _Avoid_: Endpoint, identifier, source of truth
 **Presence**:
 The current reachability interpretation for a device or endpoint.
 _Avoid_: Endpoint state, status
 **Wake Route**:
 An endpoint that has enough information and agent availability to attempt waking a device.
 _Avoid_: Device, endpoint when not wakeable
 **Known Device**:
 A device identity manually curated by the operator.
 _Avoid_: Auto-pinned device, saved observation
 **Identifier**:
 A manually approved MAC or IP value that links an observed device or endpoint to a known device.
 _Avoid_: Observation key, route id
 **Endpoint Key**:
 The typed identity of endpoint evidence, based on source and optional MAC/IP.
 _Avoid_: Stringly typed route id
 **Agent Endpoint Key**:
 An endpoint key scoped to the agent that observed it.
 _Avoid_: Concatenated agent/source/MAC/IP string
 **Agent**:
 A fleet member that observes local network state and sends device snapshots to the control plane.
 _Avoid_: Router when referring to the software actor
 **Agent Host**:
 The machine running an agent, including host identity and runtime metadata.
 _Avoid_: Device when referring to the agent machine
 **Agent Capability**:
 Something an agent host can observe or do on the network.
 _Avoid_: Router flag
 **Terminal Capability**:
 An explicitly enabled agent capability that allows the agent host to create remote PTY sessions.
 _Avoid_: Command runner, implicit root access
 **Terminal Session**:
 One operator attachment to one PTY process hosted by an agent.
 _Avoid_: Command, SSH session, stored shell
 **Terminal Relay**:
 The control plane's in-memory pairing of one operator terminal socket with one outbound agent terminal socket.
 _Avoid_: Terminal session storage, terminal emulator
 **Interface Telemetry**:
 Current operational measurements for a network interface visible to an agent.
 _Avoid_: Endpoint state, device presence
 ## Relationships
 - A **Device** has zero or more **Endpoints**.
 - A **Device Summary** is derived from a **Device** and its **Endpoints**.
 - Local source rows are grouped into **Devices** by endpoint-derived **DeviceId**, not by exact **Endpoint Key**.
 - Within one complete local snapshot, MAC+IP endpoints may absorb IP-only endpoints with the same IP; this merge is not remembered across snapshots unless the operator creates an **Identifier**.
 - An **Endpoint** belongs to exactly one **Agent**.
 - An **Endpoint** has one **Endpoint Key**.
 - An **Agent Endpoint Key** combines an **Agent** with an **Endpoint Key**.
 - An **Endpoint** may have both MAC and IP, MAC only, or IP only.
 - An **Endpoint** has exactly one **Endpoint Source**.
 - An **Endpoint** has one **Presence**.
 - An **Endpoint** may name the network interface where it was observed.
 - An **Observation Fact** may explain why an **Endpoint** exists, but does not define identity or wakeability.
 - A **Wake Route** is derived from exactly one **Endpoint**.
 - A **Wake Route** may carry the interface from its source **Endpoint**.
 - A **Known Device** has zero or more **Identifiers**.
 - An **Identifier** can link observed **Devices** or **Endpoints** to one **Known Device**.
 - An **Agent** runs on one **Agent Host**.
 - An **Agent Capability** describes what an **Agent Host** can observe or do.
 - **Terminal Capability** is an **Agent Capability** and must be explicitly enabled before an agent can host a **Terminal Session**.
 - A **Terminal Session** owns one PTY and is independent of one-shot agent commands.
 - A **Terminal Relay** pairs exactly one operator socket with exactly one agent socket for a **Terminal Session**.
 - **Interface Telemetry** describes an **Agent Host** interface, not a **Device Endpoint**.
 ## Example dialogue
 > **Dev:** "This **Device** has three IPs. Which one should the UI wake?"
 > **Domain expert:** "Do not infer that from the **Device** summary. Use the **Wake Routes** derived from its **Endpoints**."
 ## Flagged ambiguities
 - "route" was used for both observed network contact points and wakeable paths — resolved: use **Endpoint** for observed contact points and **Wake Route** only when the endpoint can be used for wake.
 - "device" was used for both an identity aggregate and each MAC/IP pair — resolved: use **Device** for the aggregate and **Endpoint** for each observed MAC/IP/source/state tuple.
 - `Device.ips` and `Device.macs` are true summary values, but they are not authoritative for wake, freshness, or per-IP state decisions — resolved: use **Endpoint** for those decisions.
 - MAC-only and IP-only observations are still **Endpoints** — resolved: **Wake Routes** require a MAC and a connected **Agent**, while IP is optional route detail.
 - Endpoint-specific states such as "removed" or "stale" are not separate concepts yet — resolved: use **Presence** until a distinction appears that presence cannot express cleanly.
 - Endpoint origin is not a free string — resolved: use **Endpoint Source** for domain logic and reserve raw strings for debug facts only.
 - Local observation file rows map naturally to **Observation Facts** — resolved: keep them for debugging, but do not use them as the operational model.
 - Offline **Endpoints** remain part of the API model — resolved: UI may collapse them from the primary view, but the API should still expose them for details, copy, and debugging.
 - **Device Summary** IPs come only from concrete live-ish sources such as neighbor table rows and current DHCP lease rows — resolved: hotplug hook memory creates **Endpoints** and **Observation Facts**, but does not directly inflate summary IPs.
 - Router-ness is not a boolean domain concept — resolved: model **Agent Capabilities** and **Agent Host** metadata instead.
 - **Presence** ordering should treat **Unknown** as non-voting/no evidence, weaker than **Offline** — resolved: concrete offline evidence should not be overridden by unknown hook or DHCP ambiguity.
 - **Device** presence is derived from all **Endpoints**, not only summary-eligible endpoints.
 - Current DHCP leases are summary-eligible **Endpoints** with **Unknown** presence; they may support wake when a MAC is present, but they do not prove reachability.
 - DHCP hook events, including removal, indicate **Unknown** because they describe lease churn rather than reachability.
 - Neighbor table and neighbor hook events may indicate **Offline** when they report failed or removed reachability.
 - **Presence** and wakeability are separate: an **Offline** endpoint may still produce a **Wake Route** if it has a MAC and a connected **Agent**.
 - **Endpoint** does not store wakeability; wakeability is derived from endpoint data plus **Agent** runtime and capability context.
 - Preferred **Wake Routes** are ordered by connected agent, wakeability, having an IP, presence quality, recency, then source quality.
 - **Endpoint** evidence preserves source-specific rows; equivalent **Wake Routes** may ignore source when they target the same agent, MAC, and IP.
 - The control plane stores **Endpoints** as structured data so fleet search, identity matching, and wake route selection do not depend on parsing opaque device JSON.
 - Summary MAC/IP collections are derived from **Endpoints**; separate MAC/IP storage should be removed or represented as views rather than maintained as independent truth.
 - API arrays should be domain-sorted by default; UI may sort top-level fleet rows for presentation, but route ranking and recommended route selection are backend-owned.
 - The main fleet API embeds **Endpoints** in each **Device** response; a separate endpoint API is unnecessary until payload size or access patterns require it.
 - The control plane stores current per-agent endpoint snapshots, not endpoint event history.
 - Agent-local hook memory is retained by local last-seen age policy, not by control-plane acknowledgement; default retention is 7 days unless configured otherwise.
 - Live-source **Endpoints** use snapshot time as their observed time; hook-derived **Endpoints** use the hook row's recorded last-seen time.
 - **DeviceId**, **Endpoint Key**, and **Agent Endpoint Key** are typed concepts; string keys are boundary serialization only.
 - **DeviceId** is derived from a device's **Endpoints**: canonical MAC if any endpoint has a MAC, otherwise canonical IP, otherwise absent.
 - Hostnames are endpoint evidence/display data, not part of **Endpoint Key** identity.
 - Interface names are endpoint metadata, not part of **Endpoint Key** identity; multi-segment routers may require scoped endpoint identity later if the same source/MAC/IP has different meaning on different interfaces.
 - An **Endpoint Key** must contain at least one network address value: MAC, IP, or both. Facts without MAC or IP remain **Observation Facts** only.
 - **Identifiers** are source-independent ownership claims over MAC or permanent IP values, not claims over endpoint sources.
 - IP **Identifiers** are explicit operator claims; Wakey does not infer whether an IP is permanent, static, or reserved.
 - **Terminal Sessions** are not agent commands — resolved: command dispatch remains request/result, while terminals use dedicated streaming sockets.
 - **Terminal Relay** is ephemeral control-plane state — resolved: terminal bytes and scrollback are not stored or audited.
 - Terminal input, output, and terminal-generated control sequences are byte streams; only lifecycle and resize operations are structured terminal protocol messages.
@@ -97,6 +97,12 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 [[package]]
 name = "arrayvec"
 version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3fb67a6e08acf24fdeccbac2cb6ac4305825bd1f117462e0e6f2f193345ad56"
 [[package]]
 name = "async-trait"
 version = "0.1.89"
@@ -1976,6 +1982,16 @@ dependencies = [
 "syn",
 ]
 [[package]]
 name = "pty-process"
 version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71cec9e2670207c5ebb9e477763c74436af3b9091dd550b9fb3c1bec7f3ea266"
 dependencies = [
 "rustix",
 "tokio",
 ]
 [[package]]
 name = "quinn"
 version = "0.11.9"
@@ -3596,9 +3612,19 @@ version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 [[package]]
 name = "vte"
 version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a5924018406ce0063cd67f8e008104968b74b563ee1b85dde3ed1f7cb87d3dbd"
 dependencies = [
 "arrayvec",
 "memchr",
 ]
 [[package]]
 name = "wakey"
-version = "0.3.0"
+version = "0.3.5"
 dependencies = [
 "anyhow",
 "chrono",
@@ -3619,7 +3645,7 @@ dependencies = [
 [[package]]
 name = "wakey-agent"
-version = "0.3.0"
+version = "0.3.5"
 dependencies = [
 "anyhow",
 "clap",
@@ -3639,11 +3665,12 @@ dependencies = [
 "url",
 "wakey",
 "wakey-core",
 "wakey-vt100",
 ]
 [[package]]
 name = "wakey-control-plane"
-version = "0.3.0"
+version = "0.3.5"
 dependencies = [
 "anyhow",
 "axum",
@@ -3672,7 +3699,7 @@ dependencies = [
 [[package]]
 name = "wakey-core"
-version = "0.3.0"
+version = "0.3.5"
 dependencies = [
 "macaddr",
 "serde",
@@ -3684,12 +3711,14 @@ dependencies = [
 [[package]]
 name = "wakey-linux"
-version = "0.3.0"
+version = "0.3.5"
 dependencies = [
 "anyhow",
 "futures",
 "lda-ipjs",
 "macaddr",
 "nix 0.31.2",
 "pty-process",
 "serde",
 "serde_json",
 "serial_test",
@@ -3697,6 +3726,15 @@ dependencies = [
 "wakey-core",
 ]
 [[package]]
 name = "wakey-vt100"
 version = "0.16.2-wakey.2"
 dependencies = [
 "itoa",
 "unicode-width",
 "vte",
 ]
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -1,6 +1,6 @@
 [package]
 name = "wakey"
-version = "0.3.0"
+version = "0.3.5"
 edition = "2024"
 publish = ["gitea"]
@@ -31,6 +31,7 @@ strip = true
 [workspace]
 members = ["ipjs", "wakey-agent", "wakey-control-plane", "wakey-core", "wakey-linux"]
 exclude = ["vendor/vt100"]
 [workspace.dependencies]
 anyhow = "1"
@@ -1,7 +1,7 @@
 # Caddy template for wakey-control-plane with Cloudflare Access.
 #
 # Security model:
-# - Public endpoints for agents: /healthz, /api/v1/agents/enroll, /api/v1/agent/ws
+# - Public endpoints for agents: health, enrollment, control WS, and scoped terminal relay WS
 # - Private admin surface: /ui/* and /api/v1/control/* (requires CF Access headers)
 #
 # Replace cp.example.com with your public control-plane domain.
@@ -10,7 +10,7 @@ wakey.ldlda.com {
    encode zstd gzip
    # Public agent-facing endpoints.
-    @public path /healthz /api/v1/agents/enroll /api/v1/agent/ws
+    @public path /healthz /api/v1/agents/enroll /api/v1/agent/ws /api/v1/agent/terminals/*
    handle @public {
        reverse_proxy 127.0.0.1:6767
    }
@@ -0,0 +1,149 @@
 # Core Endpoints and Wake Routes
 Wakey will model observed network contact points as **Endpoints** in `wakey-core`, and derive **Wake Routes** from those endpoints instead of reconstructing routes from flattened device summary MAC/IP arrays. `Device.ips` and `Device.macs` remain true summary fields for operator display and compatibility, but endpoint data is authoritative for wake, freshness, source, per-IP state, and route selection.
 **Status**: accepted
 ## Context
 The previous model stored a `Device` aggregate with summary `macs`, `ips`, `presence`, and raw observation facts. The control plane then built fleet wake routes from combinations like first MAC plus first IP. That lost source, presence, interface, and MAC/IP-pair evidence, especially when hook memory contained removed IPs or when several sources described the same address differently.
 ## Decision
 Add a typed `DeviceEndpoint` concept in `wakey-core`. A device snapshot sent by an agent contains devices with endpoints already attached. The control plane stores structured endpoint rows and derives fleet summaries and wake routes from those rows.
 Endpoint shape:
 ```rust
 DeviceEndpoint {
    key: EndpointKey,
    hostname: Option<String>,
    interface: Option<String>,
    presence: Presence,
    first_seen_unix: Option<u64>,
    last_seen_unix: Option<u64>,
 }
 EndpointKey {
    source: EndpointSource,
    mac: Option<MacAddr>,
    ip: Option<IpAddr>,
 }
 AgentEndpointKey {
    agent_id: String,
    endpoint: EndpointKey,
 }
 ```
 `EndpointKey` must contain at least one of MAC or IP. Hostname and interface are endpoint evidence/metadata, not identity. `AgentEndpointKey` may use `serde(flatten)` for wire shape, but hash values are never durable storage keys. String keys are boundary serialization only.
 ## Source and Presence Rules
 Endpoint sources are typed domain variants, not free strings:
 ```text
 Neighbor
 DhcpLease
 HookNeighbor
 HookDhcp
 ```
 Presence answers “is this reachable?”, not “can this be woken?” The presence order is:
 ```text
 Unknown < Offline < LikelyOnline < Online
 ```
 Source mapping:
 ```text
 Neighbor reachable/permanent -> Online
 Neighbor stale -> LikelyOnline
 Neighbor failed/remove-like evidence -> Offline
 Other neighbor states -> Unknown
 Current DHCP lease -> Unknown
 Hook DHCP add/update/remove -> Unknown
 Hook neighbor add/update/old -> LikelyOnline
 Hook neighbor remove -> Offline
 ```
 Current DHCP leases are summary-eligible and may support wake if they include a MAC, but they do not prove reachability. Hook memory creates endpoints and observation facts, but does not directly inflate summary IPs.
 ## Summary, Presence, and UI
 `Device.ips` and `Device.macs` stay as summaries. Summary IPs come from concrete live-ish sources such as current neighbor rows and current DHCP lease rows. Hook-derived and offline IPs remain visible through endpoints but are collapsed out of primary UI summaries by default.
 `Device.presence` is derived from all endpoints, not only summary-eligible endpoints. This lets concrete offline evidence matter while allowing stronger live evidence to override it.
 The main fleet API embeds endpoints inside each fleet device. API responses expose all endpoints, including offline and unknown endpoints. The UI may collapse offline/unknown endpoints in the primary row, but details must expose them for copy/debug/history.
 ## Wakeability and Wake Route Ordering
 Wakeability is derived, not stored on `DeviceEndpoint`.
 An endpoint is wakeable when:
 ```text
 endpoint has a MAC
 agent is connected
 agent has wake capability
 endpoint source is allowed for wake route derivation
 ```
 For now, a connected wakey-agent is assumed to have wake capability. Presence does not gate wakeability: an `Offline` endpoint may still produce a wake route, because waking powered-off devices is the core use case.
 Preferred wake route order:
 ```text
 connected agent
 wakeable route
 has IP
 presence quality
 newest last_seen
 source quality
 ```
 Presence quality for route ranking follows:
 ```text
 Online > LikelyOnline > Offline > Unknown
 ```
 Source quality follows:
 ```text
 Neighbor > DhcpLease > HookNeighbor > HookDhcp
 ```
 Equivalent wake routes may ignore endpoint source when they target the same agent, MAC, and IP. Endpoint evidence preserves source-specific rows; route grouping may deduplicate equivalent targets.
 ## Device and Identity Rules
 `DeviceId` remains the typed observed identity enum:
 ```rust
 DeviceId::Mac(MacAddr)
 DeviceId::Ip(IpAddr)
 ```
 `DeviceId` is derived from endpoints: canonical MAC if any endpoint has a MAC, otherwise canonical IP, otherwise absent. Local source rows are grouped into devices by endpoint-derived `DeviceId`, not exact `EndpointKey`.
 Within a single complete local snapshot, a MAC+IP endpoint may absorb an IP-only endpoint with the same IP. This merge is not remembered across snapshots unless the operator creates a known-device identifier.
 Known-device identifiers are source-independent ownership claims over MAC or permanent IP values. Wakey does not infer whether an IP is permanent, static, or reserved; the UI should warn the operator when attaching an IP identifier.
 ## Control Plane Storage
 The control plane stores current per-agent endpoint snapshots as structured columns, not opaque `Device` JSON and not endpoint event history. Summary MAC/IP collections are derived from endpoints; separate MAC/IP storage should be removed or represented as views rather than maintained as independent truth.
 Agent-local hook memory is retained by local last-seen age policy, not by control-plane acknowledgement. The default retention is 7 days unless configured otherwise. Live-source endpoints use snapshot time as their observed time; hook-derived endpoints use the hook row's recorded last-seen time.
 ## Consequences
 - Wake route construction moves away from `macs.first()` / `ips.first()` guessing.
 - The agent/core layer owns source interpretation because it still has local context.
 - The control plane can search, filter, match known identifiers, and rank wake routes from structured endpoint rows.
 - UI can show clean summaries while keeping complete endpoint evidence in details.
 - This preserves “wake an offline machine by MAC” without pretending that offline means not wakeable.
@@ -0,0 +1,151 @@
 # Remote Terminal Sessions
 Wakey will provide opt-in remote terminal access by pairing a browser terminal WebSocket with a dedicated outbound agent terminal WebSocket. The existing agent WebSocket remains the control channel and does not carry terminal byte streams.
 **Status**: accepted
 ## Context
 The control plane already maintains an authenticated outbound WebSocket from each connected agent. Its command protocol is intentionally request/result shaped: the control plane sends one command, the agent executes it, and one result completes the pending request.
 An interactive terminal has different semantics. It is long-lived, bidirectional, byte-oriented, and must handle window resizing, process exit, disconnect cleanup, and backpressure. Treating it as an ordinary command would either block the agent session loop or turn the main agent WebSocket into a general stream multiplexer. It would also allow terminal output to compete with heartbeats, snapshots, and wake commands.
 Agents commonly run behind NAT and must not expose an inbound listener. Terminal connections therefore remain agent-initiated and outbound.
 ## Decision
 Use one dedicated agent WebSocket and one dedicated operator WebSocket for each terminal session. The control plane holds an in-memory terminal relay that pairs those sockets.
 Session establishment follows this sequence:
 1. An authenticated operator requests a terminal for a connected, terminal-capable agent.
 2. The control plane creates an ephemeral terminal ID plus short-lived, single-use attachment credentials.
 3. The control plane sends an open-terminal control message over the existing authenticated agent WebSocket.
 4. The agent opens a new outbound terminal WebSocket to the control plane and authenticates it for that terminal ID.
 5. The browser opens the corresponding protected operator terminal WebSocket.
 6. The control plane pairs the sockets and relays terminal frames while an operator is attached.
 The main agent WebSocket carries terminal creation and cancellation control only. It does not carry PTY input or output.
 ## PTY Ownership
 The agent owns the PTY, shell process, process group, and all process cleanup. The control plane never spawns or emulates a shell.
 Use `pty-process` with its async feature as the initial PTY abstraction because it provides:
 - Tokio `AsyncRead` and `AsyncWrite` integration;
 - owned read and write halves for concurrent tasks;
 - terminal resizing;
 - child session-leader and controlling-terminal setup; and
 - a small implementation built on `rustix`.
 The PTY wrapper is cross-compiled for `armv7-unknown-linux-musleabihf` and its input, output, resize, and exit test has passed on the target router. That focused test remains part of the remote compatibility workflow. Wakey does not call `forkpty` or add its own unsafe PTY implementation.
 The executable, working directory, environment, UID, and GID are agent-controlled configuration. The browser cannot supply an arbitrary executable or process environment.
 ## Wire Protocol
 WebSocket frame type separates terminal data from terminal control:
 - Binary frames carry raw PTY input and output bytes.
 - Text JSON frames carry lifecycle, error, and resize messages.
 The terminal control vocabulary is deliberately small:
 ```text
 operator -> agent: resize, close
 control plane -> agent: snapshot
 agent -> operator: ready, exited, error
 ```
 Initial terminal dimensions are part of session attachment. Resize carries rows and columns; pixel dimensions may be added later if a demonstrated program requires them.
 Terminal behavior such as Ctrl-C, Ctrl-Z, Ctrl-D, cursor keys, mouse reporting, bracketed paste, colors, and terminal-title changes remains in the byte stream. The control plane does not parse ANSI escape sequences. The browser terminal emulator renders output and owns connected-session scrollback. The agent also feeds PTY output into a `vt100` parser so it can reconstruct the current visible screen and terminal input modes after detachment. Agent PTYs advertise `TERM=xterm-256color` and `COLORTERM=truecolor` because xterm.js is the actual frontend; applications may therefore negotiate xterm mouse reporting without a Wakey-specific mouse protocol.
 WebSockets already provide ordered, reliable delivery, so terminal frames do not carry sequence numbers in the initial protocol.
 ## Lifecycle and Cleanup
 Terminal sessions allow only one attached operator. Their lifetime belongs to the agent process, not to a browser route or a particular control-plane connection.
 When the operator socket disconnects, the session becomes detached. Navigation, browser closure, and network loss do not terminate the PTY. A protected operator request may discover the live session and obtain a fresh, single-use attachment credential. The control plane does not retain terminal output.
 The operator UI lists live sessions as tabs and stores only the active terminal ID in browser-tab-scoped `sessionStorage`. On reload it prefers that ID and briefly waits for the previous WebSocket to detach before requesting a fresh attachment credential. The stored ID is a navigation hint, not an ownership credential; another attached operator still locks the session at the control plane.
 After operator attachment, the control plane sends a `snapshot` request. The agent serializes up to 1,000 retained physical rows followed by its parsed current screen and input modes as terminal escape bytes, sends them before subsequent live output, and then signals the PTY's current foreground process group with `SIGWINCH`. Historical rows retain their terminal attributes and are replayed as ordinary terminal output so xterm builds its native scrollback; the final formatted state restores the exact live screen. The signal lets full-screen applications redraw without assuming that the original shell remains in the foreground. Signal failure is logged but never terminates the session. The connected browser independently retains up to 10,000 rows because that memory belongs to the operator device rather than the agent host.
 Wakey carries a small, read-only extension to `vt100` because its public API exposes only the active grid. A snapshot streams bounded history from the primary grid, redraws that grid with its saved cursor and attributes, and then reconstructs the alternate grid when a full-screen application is active. The parser is never resized or switched while taking a snapshot. Consequently, reconnecting during `btop` restores the application while preserving the hidden shell history and state that reappear when it exits.
 The agent keeps its terminal manager outside the control-WebSocket reconnect loop. If a dedicated terminal relay disconnects, the PTY continues draining output into the agent-owned terminal parser while waiting for replacement relay credentials. On every authenticated control connection, the agent reports its in-memory live terminal IDs and creation times. The control plane reconciles that inventory, adopts sessions missing from its volatile registry, and issues fresh relay credentials. This allows sessions to survive control-plane restart without persisting terminal state in SQLite.
 Closing a session must terminate the entire PTY process group, not only the shell process. Cleanup should send a hangup first, then escalate to termination and forced kill after bounded grace periods. Explicit operator close, absolute session timeout, agent process exit, and machine reboot close the session.
 The agent configuration sets `terminal.session_ttl_seconds` for newly created PTYs. The default is 43,200 seconds (12 hours); explicit zero disables automatic expiry. The agent owns and enforces this deadline locally because PTYs survive browser and control-plane disconnection. It advertises the policy to the control plane and includes the creation-time TTL in terminal inventory, allowing CC to mirror expiry and preserve it across CC restart. Missing fields from older agents retain the 12-hour default. Positive values are exact and values that cannot fit the platform timer are rejected rather than clamped.
 An agent process restart or machine reboot still ends every terminal session because PTY file descriptors cannot be recovered by a new process. Surviving that boundary would require an external session host such as `tmux` or a separate terminal daemon and is not part of this design.
 The agent reports a normal exit status or terminating signal when available. The UI must distinguish an exited shell from a transport failure.
 ## Backpressure and Resource Limits
 Terminal transport must not use unbounded queues.
 Every queue between PTY, agent socket, control-plane relay, and browser socket is bounded. The agent keeps draining and parsing the PTY while detached so a noisy child cannot stall the agent. Parsed state is bounded by the configured terminal dimensions and a 1,000-row reconnect scrollback limit. The control plane retains only a bounded queue of operator controls while an agent relay is reconnecting.
 While a relay is attached, saturation applies lossless backpressure instead of dropping terminal bytes or disconnecting the relay. The agent retains the frame that discovered saturation and pauses further PTY reads until bounded relay capacity returns. Input, resize, close, lifecycle, and reconnect handling remain active while output is backpressured. Reconnect snapshots use the same ordered output path and duplicate snapshot requests are coalesced while one is pending. This is required for terminal protocols such as sixel, where dropping one output frame corrupts the rest of the stream.
 When input/control and output are ready simultaneously, relay loops prioritize input and control. This keeps interrupt, resize, close, and snapshot traffic responsive while commands produce sustained output.
 The implementation also enforces:
 - maximum terminal frame size;
 - per-agent concurrent-session limits;
 - idle and absolute session timeouts;
 - bounded parsed terminal state;
 - bounded control-plane relay buffers; and
 - cleanup when any relay task exits unexpectedly.
 Exact limits are configuration and may be tuned from router testing. The bounded behavior is an architectural requirement.
 ## Security and Audit
 Remote terminal access is root-equivalent on agents that run as root. It is therefore an explicit agent capability and is disabled by default.
 Operator terminal endpoints belong to the protected control API surface. Session identifiers are not credentials. Agent and operator attachment credentials are short-lived, scoped to one terminal session, and single-use. The operator WebSocket must enforce the same-origin/protected-control assumptions used when the session was created.
 Audit records include terminal request, open, ready, disconnect, close, timeout, and exit metadata. Wakey never stores or audits terminal input, terminal output, command history, or scrollback.
 Terminal capability and session state are separate from device inventory, known-device identity, wake routes, and the debug Command Runner.
 ## Deferred Work
 Persistence across agent restart or machine reboot is not supported. A later design would need an external process owner, reconnectable local IPC, and explicit secret handling; persisted metadata alone cannot recover a PTY.
 File transfer, multi-operator attachment, terminal recording, shell-history storage, and arbitrary process launch are also deferred.
 ## Alternatives Considered
 ### Multiplex terminal bytes over the main agent WebSocket
 Rejected for the initial version. It requires refactoring the current request/result session into a general concurrent writer and stream router, adds head-of-line coupling with fleet traffic, and requires terminal-byte framing within a shared connection.
 ### Model a terminal as a long-running agent command
 Rejected. Commands have one result and a timeout; terminals have continuous bidirectional traffic and independent lifecycle.
 ### Accept an inbound connection on the agent
 Rejected. Agents run behind NAT and should not expose a new network service.
 ### Use `portable-pty`
 Viable, but not selected initially. Its cross-platform abstraction is broader than the Linux agent requires and its reader/writer API would need blocking-task bridges. It remains a fallback if `pty-process` does not build or behave correctly on the target router.
 ## Consequences
 - Each active terminal consumes two additional WebSockets and one PTY process on the agent.
 - Terminal traffic cannot delay main agent heartbeat, snapshot, or command messages.
 - Control-plane terminal state remains ephemeral; agents rebuild it from their in-memory live-session inventory after a control-plane restart.
 - The agent session protocol gains terminal-open control and capability advertisement but does not become a terminal-data multiplexer.
 - Browser and agent terminal transports can be tested independently before adding xterm.js.
 - Browser navigation and control-plane restart do not terminate an agent-owned PTY.
@@ -1,3 +1,4 @@
 *
 !.gitignore
 !copy.ps1
 !wslfix.sh
@@ -0,0 +1,7 @@
 #!/usr/bin/env bash
 set -euo pipefail
 # sometimes it breaks, run to fix
 sudo sh -c 'echo :WSLInterop:M::MZ::/init:PF > /usr/lib/binfmt.d/WSLInterop.conf'
 sudo systemctl restart systemd-binfmt
@@ -1,74 +0,0 @@
 # Report: Device State Rewrite
 ## What changed
 The control plane now stores **complete per-agent Device snapshots** instead of flat observation rows. The agent sends `Vec<Device>` (merged from DHCP, neighbors, hooks). The control plane upserts per agent, deletes stale, fleet view merges across agents at read time.
 ## Architecture (before → after)
 **Before**: Agent → raw hook observations → control plane flattens into rows → re-merges at fleet read → presence recomputed from flat actions
 **After**: Agent → inventory → `Vec<Device>` with correct presence → control plane stores as-is → fleet merge at read time from typed rows
 ## Schema
 Old tables dropped: `agent_device_observations`, `agent_device_observation_events`, `agent_observation_snapshots`, `agent_observation_snapshot_keys`
 New tables:
 - `agent_devices` — per-agent device row (keyed by `DeviceId` serialization)
 - `agent_device_macs` — MACs per device, indexed for cross-agent merge
 - `agent_device_ips` — IPs per device, indexed for cross-agent merge
 - `agent_device_hostnames` — hostnames per device
 - `agent_device_facts` — debug/source material (JSON, not identity)
 ## Concrete types throughout
 - `FleetDevice.macs`: `Vec<MacAddr>`, `ips`: `Vec<IpAddr>`, `presence`: `Presence`
 - `FleetWakeRoute.mac`: `Option<MacAddr>`, `ip`: `Option<IpAddr>`
 - `AgentDeviceWithChildren.macs`: `Vec<MacAddr>`, `ips`: `Vec<IpAddr>`
 - Row types (`AgentDeviceMacRow`, `AgentDeviceIpRow`) stay `String` from SQLite, convert via `TryFrom` impls
 - `AgentDeviceRow` has `.presence()`, `.first_seen()`, `.last_seen()` methods — no string matching in business code
 - `Presence` from wakey-core: `Ord`, `PartialOrd`, `From<&str>`, `.as_str()`
 ## Rust features used
 - `TryFrom<&AgentDeviceMacRow> for MacAddr`, `TryFrom<&AgentDeviceIpRow> for IpAddr`
 - `From<&str> for Presence`
 - `#[allow(dead_code)]` where appropriate (test-only methods, debug fields)
 - Workspace dependencies for shared crates (`macaddr`, `serde`, `tokio`, etc.)
 - Shared `TestStore` with `Drop` guard for clean test teardown
 ## What was removed
 - `AgentObservation` struct (replaced by `Device`)
 - `AgentDeviceObservation`, `AgentDeviceObservationView`, `AgentDeviceObservationEvent`, `AgentDeviceObservationInput` types
 - `inventory_result_to_observations()` — the flatten-then-rebuild function
 - `upload_agent_observations`, `list_agent_observations`, `list_agent_observation_history` API endpoints
 - `gc_stale_observations()` — no longer needed
 - `SyncObservations` CLI command from agent
 - `prune_removed_observations_from_path` calls from agent session
 - Observations page from UI
 ## What stayed
 - Agent observation store (`/tmp/wakey_observations.json`) — agent-local memory, not forwarded
 - Hotplug hooks — still update agent-local store, feed next inventory
 - Known devices + identifiers — manual lifecycle, never auto-deleted
 - Audit events, alerts — unchanged
 - `observation_retention` config field — `#[allow(dead_code)]`, kept for config file compat
 ## Verification
 ```
 cargo fmt         — clean
 cargo clippy-all  — clean (0 warnings)
 cargo test-all    — 89 tests pass, 6 ignored (on-device only)
 pnpm typecheck    — clean
 ```
 ## Remaining
 - UI cleanup: remove observations page nav entry, observation API types from `api.ts`
 - Known device identifier UI controls (API exists, UI needs affordance)
 - The `observation_retention` config field could be removed in a future cleanup
 - `list_agent_device_rows_for_agent` is `#[allow(dead_code)]` — used in tests, could be `#[cfg(test)]`
@@ -12,7 +12,7 @@ start_service() {
    procd_open_instance
    procd_set_param command "$BIN" serve --config "$CONFIG"
    procd_set_param file "$CONFIG"
-    procd_set_param env RUST_LOG=wakey_agent=debug,wakey=debug
+    # procd_set_param env RUST_LOG=wakey_agent=debug,wakey=debug
    procd_set_param respawn 5 1 0
    procd_set_param stdout 1
    procd_set_param stderr 1
@@ -0,0 +1,111 @@
 #!/usr/bin/env -S uv run --script
 # /// script
 # requires-python = ">=3.11"
 # dependencies = [
 #   "brotli==1.2.0",
 #   "fonttools==4.63.0",
 # ]
 # ///
 """Rebuild Wakey's self-hosted terminal webfont from Nerd Fonts."""
 from __future__ import annotations
 import hashlib
 import os
 import shutil
 import tarfile
 import tempfile
 import urllib.request
 from pathlib import Path
 from fontTools.ttLib import TTFont
 NERD_FONTS_VERSION = "v3.4.0"
 ARCHIVE_SHA256 = "ef552a3e638f25125c6ad4c51176a6adcdce295ab1d2ffacf0db060caf8c1582"
 WOFF2_SHA256 = "50680a64466fbcc3eff68e00f84505f55681c86f8450c042416af5a8dbc1cce1"
 FONT_FILE = "JetBrainsMonoNerdFontMono-Regular"
 ARCHIVE_URL = (
    "https://github.com/ryanoasis/nerd-fonts/releases/download/"
    f"{NERD_FONTS_VERSION}/JetBrainsMono.tar.xz"
 )
 ROOT = Path(__file__).resolve().parent.parent
 OUTPUT_DIR = ROOT / "ui/src/assets/fonts/jetbrains-mono-nerd"
 def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as source:
        for chunk in iter(lambda: source.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()
 def verify_sha256(path: Path, expected: str) -> None:
    actual = sha256(path)
    if actual != expected:
        raise RuntimeError(
            f"checksum mismatch for {path}\nexpected: {expected}\nactual:   {actual}"
        )
 def download(url: str, destination: Path) -> None:
    request = urllib.request.Request(url, headers={"User-Agent": "wakey-font-preparer"})
    with (
        urllib.request.urlopen(request, timeout=60) as response,
        destination.open("wb") as output,
    ):
        shutil.copyfileobj(response, output)
 def extract_member(archive: tarfile.TarFile, name: str, destination: Path) -> None:
    source = archive.extractfile(name)
    if source is None:
        raise RuntimeError(f"missing {name} in Nerd Fonts archive")
    with source, destination.open("wb") as output:
        shutil.copyfileobj(source, output)
 def install_file(source: Path, destination: Path) -> None:
    """Atomically replace an asset without exposing a partial file to Vite."""
    temporary = destination.with_name(f".{destination.name}.tmp")
    try:
        shutil.copyfile(source, temporary)
        os.chmod(temporary, 0o644)
        temporary.replace(destination)
    finally:
        temporary.unlink(missing_ok=True)
 def main() -> None:
    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
    with tempfile.TemporaryDirectory(prefix="wakey-terminal-font.") as temp:
        work_dir = Path(temp)
        archive_path = work_dir / "JetBrainsMono.tar.xz"
        ttf_path = work_dir / f"{FONT_FILE}.ttf"
        woff2_path = work_dir / f"{FONT_FILE}.woff2"
        license_path = work_dir / "OFL.txt"
        print(f"Downloading Nerd Fonts {NERD_FONTS_VERSION} JetBrainsMono archive")
        download(ARCHIVE_URL, archive_path)
        verify_sha256(archive_path, ARCHIVE_SHA256)
        with tarfile.open(archive_path, "r:xz") as archive:
            extract_member(archive, ttf_path.name, ttf_path)
            extract_member(archive, license_path.name, license_path)
        # FontTools otherwise stamps the current time into the head table,
        # making equivalent rebuilds produce different WOFF2 files.
        font = TTFont(ttf_path, recalcTimestamp=False)
        font.flavor = "woff2"
        font.save(woff2_path)
        verify_sha256(woff2_path, WOFF2_SHA256)
        install_file(woff2_path, OUTPUT_DIR / woff2_path.name)
        install_file(license_path, OUTPUT_DIR / license_path.name)
    print(f"Prepared {OUTPUT_DIR / f'{FONT_FILE}.woff2'}")
 if __name__ == "__main__":
    main()
@@ -54,17 +54,21 @@ if ($Publish) {
        Write-Host 'No -Registry provided; defaulting publish target to registry: gitea'
    }
-    $publishOrder = @(
+    # Patched external crates are excluded from the workspace, so publish
-        'lda-ipjs',
+    # them by manifest path before workspace packages that depend on them.
-        'wakey-core',
+    $publishTargets = @(
-        'wakey-linux',
+        @{ Name = 'wakey-vt100'; Args = @('publish', '--manifest-path', 'vendor/vt100/Cargo.toml') },
-        'wakey',
+        @{ Name = 'lda-ipjs'; Args = @('publish', '-p', 'lda-ipjs') },
-        'wakey-agent',
+        @{ Name = 'wakey-core'; Args = @('publish', '-p', 'wakey-core') },
-        'wakey-control-plane'
+        @{ Name = 'wakey-linux'; Args = @('publish', '-p', 'wakey-linux') },
        @{ Name = 'wakey'; Args = @('publish', '-p', 'wakey') },
        @{ Name = 'wakey-agent'; Args = @('publish', '-p', 'wakey-agent') },
        @{ Name = 'wakey-control-plane'; Args = @('publish', '-p', 'wakey-control-plane') }
    )
-    foreach ($pkg in $publishOrder) {
+    foreach ($target in $publishTargets) {
-        $pubArgs = @('publish', '-p', $pkg)
+        $pkg = $target.Name
        $pubArgs = @($target.Args)
        if ($Registry) { $pubArgs += @('--registry', $Registry) }
        Write-Host ("publishing {0}..." -f $pkg)
@@ -110,6 +110,16 @@ update_existing_repo() {
    git -C "$repo_dir" pull --ff-only origin "$ref" || fail 'git pull --ff-only failed'
 }
 update_submodules() {
    repo_dir=$1
    # Sync first so an updated .gitmodules URL is honored by an existing
    # checkout, then initialize and pin every nested submodule to the commit
    # recorded by the parent repository.
    git -C "$repo_dir" submodule sync --recursive || fail 'git submodule sync failed'
    git -C "$repo_dir" submodule update --init --recursive || fail 'git submodule update failed'
 }
 install_executable_force() {
    src=$1
    dst=$2
@@ -186,6 +196,7 @@ main() {
        git clone --depth 1 --branch "$REF" "$REPO_URL" "$WORKDIR" ||
            fail 'git clone failed'
    fi
    update_submodules "$WORKDIR"
    cd "$WORKDIR"
@@ -13,6 +13,7 @@ pub use service::{
 };
 pub use wakey_linux::observations::{
    list_local_observations, observe_dhcp_event, observe_neighbor_event,
    prune_stale_observations_from_path,
 };
 #[cfg(test)]
@@ -77,7 +77,7 @@ pub fn merge_devices_with_observations(
        let key = row
            .mac
            .map(|m| m.to_string())
-            .unwrap_or_else(|| format!("ip:{}", row.ip));
+            .unwrap_or_else(|| format!("ip:{}", row.ip)); // key by mac or by FAILED ip
        by_key.entry(key).or_default().0.push(row);
    }
    for lease in leases {
@@ -99,7 +99,7 @@ pub fn merge_devices_with_observations(
            Device::from_parts_with_observations(neighbors, leases, observations)
        })
        .collect();
-
+    if !query.is_empty() {
        let mut texts = Vec::new();
        let mut devs = Vec::new();
        let mut ips = Vec::new();
@@ -123,6 +123,7 @@ pub fn merge_devices_with_observations(
            && (macs.is_empty() || device.macs.iter().any(|mac| macs.contains(mac)))
            && (nuds.is_empty() || device.neighbors.iter().any(|n| nuds.contains(&n.state)))
        });
    }
    devices.sort_by(|a, b| {
        presence_rank(b.presence)
            .cmp(&presence_rank(a.presence))
@@ -180,7 +181,7 @@ const fn presence_rank(presence: Presence) -> u8 {
 mod tests {
    use super::*;
    use std::net::{IpAddr, Ipv4Addr};
-    use wakey_core::{DeviceId, DhcpLease, InventoryQueryBuilder, NeighborState};
+    use wakey_core::{DeviceId, DhcpLease, EndpointSource, InventoryQueryBuilder, NeighborState};
    fn sample_neighbors() -> Vec<NeighborEntry> {
        vec![NeighborEntry {
@@ -278,11 +279,14 @@ mod tests {
            Some(DeviceId::Mac("aa:bb:cc:dd:ee:ff".parse().expect("mac")))
        );
        assert_eq!(out[0].observations.len(), 1);
        assert_eq!(out[0].endpoints.len(), 1);
        assert_eq!(out[0].endpoints[0].key.source, EndpointSource::HookDhcp);
        assert!(out[0].ips.is_empty());
        assert_eq!(out[0].presence, Presence::Unknown);
    }
    #[test]
-    fn merge_devices_marks_remove_only_observation_offline() {
+    fn merge_devices_marks_neigh_remove_observation_offline() {
        let query = InventoryQueryBuilder::new().build();
        let out = merge_devices_with_observations(
            Vec::new(),
@@ -301,5 +305,56 @@ mod tests {
        assert_eq!(out.len(), 1);
        assert_eq!(out[0].presence, Presence::Offline);
        assert_eq!(out[0].endpoints[0].key.source, EndpointSource::HookNeighbor);
        assert!(out[0].ips.is_empty());
    }
    #[test]
    fn merge_devices_keeps_dhcp_remove_observation_unknown() {
        let query = InventoryQueryBuilder::new().build();
        let out = merge_devices_with_observations(
            Vec::new(),
            Vec::new(),
            vec![DeviceObservationFact {
                kind: "dhcp".into(),
                action: "remove".into(),
                mac: Some("aa:bb:cc:dd:ee:ff".parse().expect("mac")),
                ip: Some(IpAddr::V4(Ipv4Addr::new(192, 168, 1, 30))),
                hostname: None,
                first_seen_unix: Some(10),
                last_seen_unix: Some(20),
            }],
            &query,
        );
        assert_eq!(out.len(), 1);
        assert_eq!(out[0].presence, Presence::Unknown);
        assert_eq!(out[0].endpoints[0].key.source, EndpointSource::HookDhcp);
        assert!(out[0].ips.is_empty());
    }
    #[test]
    fn merge_devices_uses_ip_id_for_ip_only_hook_endpoint_without_summary_ip() {
        let query = InventoryQueryBuilder::new().build();
        let ip = IpAddr::V4(Ipv4Addr::new(192, 168, 1, 31));
        let out = merge_devices_with_observations(
            Vec::new(),
            Vec::new(),
            vec![DeviceObservationFact {
                kind: "neigh".into(),
                action: "remove".into(),
                mac: None,
                ip: Some(ip),
                hostname: None,
                first_seen_unix: Some(10),
                last_seen_unix: Some(20),
            }],
            &query,
        );
        assert_eq!(out.len(), 1);
        assert_eq!(out[0].id, Some(DeviceId::Ip(ip)));
        assert!(out[0].ips.is_empty());
        assert_eq!(out[0].endpoints.len(), 1);
    }
 }
@@ -0,0 +1,3 @@
 package-lock.json
 pnpm-lock.yaml
 yarn.lock
@@ -2,8 +2,25 @@
 <html lang="en">
  <head>
    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta
      name="viewport"
      content="width=device-width, initial-scale=1.0, interactive-widget=resizes-content"
    />
    <title>Wakey Operator UI</title>
    <script>
      (function () {
        try {
          var t = localStorage.getItem("wakey-ui-theme");
          if (
            t === "dark" ||
            ((t === "system" || !t) &&
              window.matchMedia("(prefers-color-scheme: dark)").matches)
          ) {
            document.documentElement.classList.add("dark");
          }
        } catch (_) {}
      })();
    </script>
  </head>
  <body>
    <div id="root"></div>
@@ -15,6 +15,13 @@
    "@base-ui/react": "^1.4.0",
    "@fontsource-variable/inter": "^5.2.8",
    "@tailwindcss/vite": "^4.2.2",
    "@xterm/addon-clipboard": "0.3.0-beta.290",
    "@xterm/addon-fit": "0.12.0-beta.290",
    "@xterm/addon-image": "0.10.0-beta.290",
    "@xterm/addon-unicode-graphemes": "0.5.0-beta.290",
    "@xterm/addon-unicode11": "0.10.0-beta.290",
    "@xterm/addon-web-links": "0.13.0-beta.290",
    "@xterm/xterm": "6.1.0-beta.290",
    "class-variance-authority": "^0.7.1",
    "clsx": "^2.1.1",
    "lucide-react": "^1.8.0",
@@ -0,0 +1,3 @@
 allowBuilds:
  esbuild: false
  msw: false
@@ -1,4 +1,4 @@
-import { useEffect, useState } from "react";
+import { lazy, Suspense, useEffect, useState } from "react";
 import { Navigate, Route, Routes } from "react-router-dom";
 import { toast } from "sonner";
@@ -15,6 +15,7 @@ import {
  setAgentNickname,
 } from "@/api";
 import { Toaster } from "@/components/ui/sonner";
 import { Skeleton } from "@/components/ui/skeleton";
 import { AppLayout } from "@/layout/AppLayout";
 import { AgentsPage } from "@/pages/AgentsPage";
 import { AlertsPage } from "@/pages/AlertsPage";
@@ -23,6 +24,12 @@ import { CommandsPage } from "@/pages/CommandsPage";
 import { DashboardPage } from "@/pages/DashboardPage";
 import { DevicesPage } from "@/pages/DevicesPage";
 import { TokensPage } from "@/pages/TokensPage";
 const TerminalPage = lazy(() =>
  import("@/pages/TerminalPage").then((module) => ({
    default: module.TerminalPage,
  })),
 );
 import { WakeToolsPage } from "@/pages/WakeToolsPage";
 type LoadState = "idle" | "loading" | "ready" | "error";
@@ -144,6 +151,7 @@ export function App() {
                selectedAgentId={selectedAgentId}
                onSelectAgent={setSelectedAgentId}
                onAfterWake={loadAll}
                onRefresh={loadAll}
              />
            }
          />
@@ -214,6 +222,22 @@ export function App() {
            }
          />
          <Route path="tokens" element={<TokensPage />} />
          <Route
            path="terminal"
            element={
              <Suspense
                fallback={
                  <Skeleton className="h-[calc(100dvh-2.5rem)] w-full" />
                }
              >
                <TerminalPage
                  agents={agents}
                  selectedAgentId={selectedAgentId}
                  onSelectAgent={setSelectedAgentId}
                />
              </Suspense>
            }
          />
          <Route path="*" element={<Navigate to="/" replace />} />
        </Route>
@@ -2,6 +2,21 @@ export type Agent = {
  agent_id: string;
  connected: boolean;
  nickname?: string | null;
  capabilities: "terminal"[];
  capability_options?: {
    terminal?: { max_sessions: number };
  };
 };
 export type TerminalSession = {
  terminal_id: string;
  agent_id: string;
  created_at_unix: number;
  expires_at_unix?: number | null;
  agent_attached: boolean;
  operator_attached: boolean;
  websocket_url: string;
  attachment_token?: string;
 };
 export type Alert = {
@@ -103,6 +118,20 @@ export type FleetDeviceAgent = {
  last_seen_unix: number;
 };
 export type FleetDeviceEndpoint = {
  agent_id: string;
  nickname?: string | null;
  connected: boolean;
  source: string;
  mac: string | null;
  ip: string | null;
  hostname: string | null;
  interface: string | null;
  presence: string;
  first_seen_unix: number | null;
  last_seen_unix: number | null;
 };
 export type FleetWakeRoute = {
  route_id: string;
  agent_id: string;
@@ -111,7 +140,9 @@ export type FleetWakeRoute = {
  mac: string | null;
  ip: string | null;
  hostname: string | null;
  interface: string | null;
  source: string;
  presence: string;
  last_seen_unix: number;
  wakeable: boolean;
 };
@@ -126,6 +157,7 @@ export type FleetDevice = {
  hostnames: string[];
  agents: FleetDeviceAgent[];
  sources: string[];
  endpoints: FleetDeviceEndpoint[];
  first_seen_unix: number | null;
  last_seen_unix: number | null;
  presence: string;
@@ -208,6 +240,44 @@ export function fetchAgents(): Promise<Agent[]> {
  return request<Agent[]>("/api/v1/control/agents");
 }
 export function createTerminal(
  agentId: string,
  rows: number,
  cols: number,
 ): Promise<TerminalSession> {
  return request<TerminalSession>("/api/v1/control/terminals", {
    method: "POST",
    body: JSON.stringify({ agent_id: agentId, rows, cols }),
  });
 }
 export function listTerminals(): Promise<TerminalSession[]> {
  return request<TerminalSession[]>("/api/v1/control/terminals");
 }
 export function attachTerminal(
  terminalId: string,
  operatorId: string,
 ): Promise<TerminalSession> {
  return request<TerminalSession>(
    `/api/v1/control/terminals/${encodeURIComponent(terminalId)}/attach`,
    {
      method: "POST",
      body: JSON.stringify({ operator_id: operatorId }),
    },
  );
 }
 export async function closeTerminal(terminalId: string): Promise<void> {
  const response = await fetch(
    `/api/v1/control/terminals/${encodeURIComponent(terminalId)}`,
    { method: "DELETE" },
  );
  if (!response.ok) {
    throw new Error(`Failed to close terminal: ${response.status}`);
  }
 }
 export function fetchAlerts(): Promise<Alert[]> {
  return request<Alert[]>("/api/v1/control/alerts");
 }
@@ -0,0 +1,93 @@
 Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
 This Font Software is licensed under the SIL Open Font License, Version 1.1.
 This license is copied below, and is also available with a FAQ at:
 https://scripts.sil.org/OFL
 -----------------------------------------------------------
 SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
 -----------------------------------------------------------
 PREAMBLE
 The goals of the Open Font License (OFL) are to stimulate worldwide
 development of collaborative font projects, to support the font creation
 efforts of academic and linguistic communities, and to provide a free and
 open framework in which fonts may be shared and improved in partnership
 with others.
 The OFL allows the licensed fonts to be used, studied, modified and
 redistributed freely as long as they are not sold by themselves. The
 fonts, including any derivative works, can be bundled, embedded, 
 redistributed and/or sold with any software provided that any reserved
 names are not used by derivative works. The fonts and derivatives,
 however, cannot be released under any other type of license. The
 requirement for fonts to remain under this license does not apply
 to any document created using the fonts or their derivatives.
 DEFINITIONS
 "Font Software" refers to the set of files released by the Copyright
 Holder(s) under this license and clearly marked as such. This may
 include source files, build scripts and documentation.
 "Reserved Font Name" refers to any names specified as such after the
 copyright statement(s).
 "Original Version" refers to the collection of Font Software components as
 distributed by the Copyright Holder(s).
 "Modified Version" refers to any derivative made by adding to, deleting,
 or substituting -- in part or in whole -- any of the components of the
 Original Version, by changing formats or by porting the Font Software to a
 new environment.
 "Author" refers to any designer, engineer, programmer, technical
 writer or other person who contributed to the Font Software.
 PERMISSION & CONDITIONS
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of the Font Software, to use, study, copy, merge, embed, modify,
 redistribute, and sell modified and unmodified copies of the Font
 Software, subject to the following conditions:
 1) Neither the Font Software nor any of its individual components,
 in Original or Modified Versions, may be sold by itself.
 2) Original or Modified Versions of the Font Software may be bundled,
 redistributed and/or sold with any software, provided that each copy
 contains the above copyright notice and this license. These can be
 included either as stand-alone text files, human-readable headers or
 in the appropriate machine-readable metadata fields within text or
 binary files as long as those fields can be easily viewed by the user.
 3) No Modified Version of the Font Software may use the Reserved Font
 Name(s) unless explicit written permission is granted by the corresponding
 Copyright Holder. This restriction only applies to the primary font name as
 presented to the users.
 4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
 Software shall not be used to promote, endorse or advertise any
 Modified Version, except to acknowledge the contribution(s) of the
 Copyright Holder(s) and the Author(s) or with their explicit written
 permission.
 5) The Font Software, modified or unmodified, in part or in whole,
 must be distributed entirely under this license, and must not be
 distributed under any other license. The requirement for fonts to
 remain under this license does not apply to any document created
 using the Font Software.
 TERMINATION
 This license becomes null and void if any of the above conditions are
 not met.
 DISCLAIMER
 THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
 COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
 DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
 OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -0,0 +1,16 @@
 # JetBrainsMono Nerd Font Mono
 `JetBrainsMonoNerdFontMono-Regular.woff2` is the regular monospaced variant
 from Nerd Fonts v3.4.0 (JetBrains Mono v2.304), converted from the release TTF
 to WOFF2 without subsetting.
 Source archive:
 https://github.com/ryanoasis/nerd-fonts/releases/download/v3.4.0/JetBrainsMono.tar.xz
 The font is distributed under the SIL Open Font License in `OFL.txt`.
 Rebuild the checked-in webfont with:
 ```sh
 ./scripts/prepare_terminal_font.py
 ```
@@ -12,6 +12,7 @@ import {
  FileText,
  Key,
  Terminal,
  SquareTerminal,
  PanelLeftClose,
  PanelLeft,
 } from "lucide-react";
@@ -57,6 +58,7 @@ const navSections: NavSection[] = [
      { to: "/audit", label: "Audit", icon: FileText },
      { to: "/tokens", label: "Tokens", icon: Key },
      { to: "/commands", label: "Commands", icon: Terminal },
      { to: "/terminal", label: "Terminal", icon: SquareTerminal },
    ],
  },
 ];
@@ -93,7 +95,7 @@ export function AppLayout() {
        className={[
          "sidebar",
          collapsed ? "sidebar--collapsed" : "",
-          "fixed inset-y-0 left-0 z-50 shadow-xl transition-all duration-300 ease-in-out",
+          "fixed inset-y-0 left-0 z-50 shadow-xl transition-all duration-100 ease-in-out",
          "md:sticky md:top-0 md:z-30 md:shadow-none",
          collapsed ? "-translate-x-full md:translate-x-0" : "translate-x-0",
        ]
@@ -219,8 +221,14 @@ export function AppLayout() {
      {/* Mobile backdrop */}
      {!collapsed && (
        <div
          role="button"
          tabIndex={0}
          className="fixed inset-0 z-40 bg-black/20 md:hidden animate-in fade-in duration-200"
          onClick={() => setCollapsed(true)}
          onKeyDown={(e) => {
            if (e.key === "Enter" || e.key === " ") setCollapsed(true);
          }}
          aria-label="Close menu"
        />
      )}
@@ -4,6 +4,7 @@ import { BrowserRouter } from "react-router-dom";
 import { ThemeProvider } from "next-themes";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { App } from "@/App";
 import "@xterm/xterm/css/xterm.css";
 import "./styles.css";
 createRoot(document.getElementById("root")!).render(
@@ -72,7 +72,10 @@ export function AlertsPage({ alerts, transitions, onRefresh }: Props) {
        </CardHeader>
        <CardContent className="space-y-3">
          <div className="grid gap-2 sm:grid-cols-3">
-            <label className="grid gap-1 text-sm text-muted-foreground">
+            <label
              htmlFor="alert-severity"
              className="grid gap-1 text-sm text-muted-foreground"
            >
              Severity
              <Select
                value={severity}
@@ -80,7 +83,7 @@ export function AlertsPage({ alerts, transitions, onRefresh }: Props) {
                  if (value) setSeverity(value);
                }}
              >
-                <SelectTrigger className="w-full">
+                <SelectTrigger id="alert-severity" className="w-full">
                  <SelectValue placeholder="Severity" />
                </SelectTrigger>
                <SelectContent>
@@ -93,7 +96,10 @@ export function AlertsPage({ alerts, transitions, onRefresh }: Props) {
              </Select>
            </label>
-            <label className="grid gap-1 text-sm text-muted-foreground">
+            <label
              htmlFor="alert-status"
              className="grid gap-1 text-sm text-muted-foreground"
            >
              Status
              <Select
                value={status}
@@ -101,7 +107,7 @@ export function AlertsPage({ alerts, transitions, onRefresh }: Props) {
                  if (value) setStatus(value);
                }}
              >
-                <SelectTrigger className="w-full">
+                <SelectTrigger id="alert-status" className="w-full">
                  <SelectValue placeholder="Status" />
                </SelectTrigger>
                <SelectContent>
@@ -114,7 +120,10 @@ export function AlertsPage({ alerts, transitions, onRefresh }: Props) {
              </Select>
            </label>
-            <label className="grid gap-1 text-sm text-muted-foreground">
+            <label
              htmlFor="alert-kind"
              className="grid gap-1 text-sm text-muted-foreground"
            >
              Kind
              <Select
                value={kind}
@@ -122,7 +131,7 @@ export function AlertsPage({ alerts, transitions, onRefresh }: Props) {
                  if (value) setKind(value);
                }}
              >
-                <SelectTrigger className="w-full">
+                <SelectTrigger id="alert-kind" className="w-full">
                  <SelectValue placeholder="Kind" />
                </SelectTrigger>
                <SelectContent>
@@ -170,9 +179,13 @@ export function AlertsPage({ alerts, transitions, onRefresh }: Props) {
          </span>
        </CardHeader>
        <CardContent className="space-y-2">
-          <label className="grid gap-1 text-sm text-muted-foreground">
+          <label
            htmlFor="alert-transition-search"
            className="grid gap-1 text-sm text-muted-foreground"
          >
            Search
            <Input
              id="alert-transition-search"
              value={transitionQ}
              onChange={(e) => setTransitionQ(e.target.value)}
              placeholder="kind, status, message, agent"
@@ -70,7 +70,10 @@ export function AuditPage({ events, onRefresh }: Props) {
      <CardContent className="space-y-3">
        <div className="grid gap-2 sm:grid-cols-3">
-          <label className="grid gap-1 text-sm text-muted-foreground">
+          <label
            htmlFor="audit-event-type"
            className="grid gap-1 text-sm text-muted-foreground"
          >
            Event type
            <Select
              value={eventType}
@@ -78,7 +81,7 @@ export function AuditPage({ events, onRefresh }: Props) {
                if (value) setEventType(value);
              }}
            >
-              <SelectTrigger className="w-full">
+              <SelectTrigger id="audit-event-type" className="w-full">
                <SelectValue placeholder="Event type" />
              </SelectTrigger>
              <SelectContent>
@@ -91,7 +94,10 @@ export function AuditPage({ events, onRefresh }: Props) {
            </Select>
          </label>
-          <label className="grid gap-1 text-sm text-muted-foreground">
+          <label
            htmlFor="audit-outcome"
            className="grid gap-1 text-sm text-muted-foreground"
          >
            Outcome
            <Select
              value={outcome}
@@ -99,7 +105,7 @@ export function AuditPage({ events, onRefresh }: Props) {
                if (value) setOutcome(value);
              }}
            >
-              <SelectTrigger className="w-full">
+              <SelectTrigger id="audit-outcome" className="w-full">
                <SelectValue placeholder="Outcome" />
              </SelectTrigger>
              <SelectContent>
@@ -112,9 +118,13 @@ export function AuditPage({ events, onRefresh }: Props) {
            </Select>
          </label>
-          <label className="grid gap-1 text-sm text-muted-foreground">
+          <label
            htmlFor="audit-search"
            className="grid gap-1 text-sm text-muted-foreground"
          >
            Search
            <Input
              id="audit-search"
              value={needle}
              onChange={(e) => setNeedle(e.target.value)}
              placeholder="message, agent, actor"
@@ -66,12 +66,15 @@ export function CommandsPage({
          Command Runner
        </CardTitle>
        <CardDescription>
-          Debug tool — send raw commands to agents and inspect JSON responses
+          Debug tool: send raw commands to agents and inspect JSON responses
        </CardDescription>
      </CardHeader>
      <CardContent>
        <form className="grid gap-3" onSubmit={submit}>
-          <label className="grid gap-1 text-sm text-muted-foreground">
+          <label
            htmlFor="cmd-agent"
            className="grid gap-1 text-sm text-muted-foreground"
          >
            <span>Agent</span>
            <AgentSelector
              agents={agents}
@@ -80,13 +83,16 @@ export function CommandsPage({
            />
          </label>
-          <label className="grid gap-1 text-sm text-muted-foreground">
+          <label
            htmlFor="cmd-kind"
            className="grid gap-1 text-sm text-muted-foreground"
          >
            <span>Command</span>
            <Select
              value={kind}
              onValueChange={(value) => setKind(value as CommandKind)}
            >
-              <SelectTrigger className="w-full">
+              <SelectTrigger id="cmd-kind" className="w-full">
                <SelectValue placeholder="Pick command" />
              </SelectTrigger>
              <SelectContent>
@@ -98,9 +104,13 @@ export function CommandsPage({
            </Select>
          </label>
-          <label className="grid gap-1 text-sm text-muted-foreground">
+          <label
            htmlFor="cmd-query"
            className="grid gap-1 text-sm text-muted-foreground"
          >
            <span>Query</span>
            <Input
              id="cmd-query"
              value={query}
              onChange={(e) => setQuery(e.target.value)}
              placeholder="optional"
@@ -115,7 +115,7 @@ export function DashboardPage({
    <section className="grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
      {/* Fleet Status */}
      <Card>
-        <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+        <CardHeader className="flex flex-row items-center justify-between gap-y-0 pb-2">
          <CardDescription className="flex items-center gap-1.5">
            <Bot className="size-3.5" />
            Fleet Status
@@ -152,7 +152,7 @@ export function DashboardPage({
      {/* Active Alerts */}
      <Card>
-        <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+        <CardHeader className="flex flex-row items-center justify-between gap-y-0 pb-2">
          <CardDescription className="flex items-center gap-1.5">
            <Bell className="size-3.5" />
            Active Alerts
@@ -188,7 +188,7 @@ export function DashboardPage({
      {/* Transitions */}
      <Card>
-        <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+        <CardHeader className="flex flex-row items-center justify-between gap-y-0 pb-2">
          <CardDescription className="flex items-center gap-1.5">
            <Activity className="size-3.5" />
            Transitions
@@ -206,7 +206,7 @@ export function DashboardPage({
      {/* Token Health */}
      <Card>
-        <CardHeader className="flex flex-row items-center justify-between space-y-0 pb-2">
+        <CardHeader className="flex flex-row items-center justify-between gap-y-0 pb-2">
          <CardDescription className="flex items-center gap-1.5">
            <Key className="size-3.5" />
            Enroll Tokens
@@ -228,7 +228,7 @@ export function DashboardPage({
      {/* Recent Activity Feed */}
      <Card className="sm:col-span-2 lg:col-span-4">
-        <CardHeader className="flex flex-row items-start justify-between gap-3 space-y-0">
+        <CardHeader className="flex flex-row items-start justify-between gap-3 gap-y-0">
          <div>
            <CardTitle>Recent Activity</CardTitle>
            <CardDescription className="mt-1">
@@ -51,9 +51,10 @@ type Props = {
  selectedAgentId: string;
  onSelectAgent: (agentId: string) => void;
  onAfterWake?: () => Promise<void>;
  onRefresh?: () => Promise<void>;
 };
-export function DevicesPage({ agents, onAfterWake }: Props) {
+export function DevicesPage({ agents, onAfterWake, onRefresh }: Props) {
  const [devices, setDevices] = useState<FleetDevice[]>([]);
  const [knownDevices, setKnownDevices] = useState<KnownDevice[]>([]);
  const [query, setQuery] = useState("");
@@ -137,8 +138,7 @@ export function DevicesPage({ agents, onAfterWake }: Props) {
    } catch {
      const area = document.createElement("textarea");
      area.value = text;
-      area.style.position = "fixed";
+      area.style.cssText = "position:fixed;opacity:0";
      area.style.opacity = "0";
      document.body.appendChild(area);
      area.select();
      document.execCommand("copy");
@@ -201,7 +201,10 @@ export function DevicesPage({ agents, onAfterWake }: Props) {
              <Button
                variant="outline"
                size="sm"
-                onClick={() => void loadFleet()}
+                onClick={() => {
                  void loadFleet();
                  if (onRefresh) void onRefresh();
                }}
                disabled={loading}
              >
                <RefreshCw className="size-4" aria-hidden />
@@ -222,11 +225,15 @@ export function DevicesPage({ agents, onAfterWake }: Props) {
        </CardHeader>
        <CardContent className="space-y-3">
          <div className="grid gap-2 lg:grid-cols-[minmax(16rem,1fr)_11rem_10rem_14rem_10rem]">
-            <label className="grid gap-1 text-sm text-muted-foreground">
+            <label
              htmlFor="fleet-search"
              className="grid gap-1 text-sm text-muted-foreground"
            >
              <span>Search</span>
              <div className="relative">
                <Search className="absolute left-2 top-2.5 size-4 text-muted-foreground" />
                <Input
                  id="fleet-search"
                  className="pl-8"
                  value={query}
                  onChange={(event) => setQuery(event.target.value)}
@@ -246,7 +253,10 @@ export function DevicesPage({ agents, onAfterWake }: Props) {
              values={knownFilters}
              onChange={(value) => setKnown(value as KnownFilter)}
            />
-            <label className="grid gap-1 text-sm text-muted-foreground">
+            <label
              htmlFor="fleet-agent"
              className="grid gap-1 text-sm text-muted-foreground"
            >
              <span>Agent</span>
              <Select
                value={agentId}
@@ -334,6 +344,7 @@ export function DevicesPage({ agents, onAfterWake }: Props) {
      </Card>
      <FleetDeviceDetailsDialog
        key={details?.device_key ?? "__none"}
        device={details}
        knownDevices={knownDevices}
        open={Boolean(details)}
@@ -0,0 +1,927 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { ClipboardAddon } from "@xterm/addon-clipboard";
 import { FitAddon } from "@xterm/addon-fit";
 import { ImageAddon } from "@xterm/addon-image";
 import { Unicode11Addon } from "@xterm/addon-unicode11";
 import { UnicodeGraphemesAddon } from "@xterm/addon-unicode-graphemes";
 import { WebLinksAddon } from "@xterm/addon-web-links";
 import { Terminal as XTerm } from "@xterm/xterm";
 import { Eraser, Keyboard, RotateCcw, Terminal } from "lucide-react";
 import { toast } from "sonner";
 import {
  APIError,
  type Agent,
  type TerminalSession,
  attachTerminal,
  closeTerminal,
  createTerminal,
  listTerminals,
 } from "@/api";
 import { AgentSelector, displayAgentLabel } from "@/components/AgentSelector";
 import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import {
  Tooltip,
  TooltipContent,
  TooltipTrigger,
 } from "@/components/ui/tooltip";
 import {
  MAX_TERMINAL_FONT_SIZE,
  MIN_TERMINAL_FONT_SIZE,
  TerminalAccessoryBar,
 } from "@/pages/terminal/TerminalAccessoryBar";
 import { TerminalSessionTabs } from "@/pages/terminal/TerminalSessionTabs";
 import {
  NO_TERMINAL_MODIFIERS,
  applyTerminalModifiers,
  mergeTerminalSession,
  orderTerminalSessions,
  reconcileTerminalSessions,
  restoreCandidates,
  visibleTerminalText,
  type TerminalConnectionState,
  type TerminalModifiers,
 } from "@/pages/terminal/sessionUtils";
 import { loadTerminalFontFamily } from "@/terminal/terminalFonts";
 type Props = {
  agents: Agent[];
  selectedAgentId: string;
  onSelectAgent: (agentId: string) => void;
 };
 const REMEMBERED_TERMINAL_KEY = "wakey.active-terminal-id";
 const TERMINAL_OPERATOR_KEY = "wakey.terminal-operator-id";
 const DEFAULT_TERMINAL_FONT_SIZE = 14;
 const TERMINAL_TOUCH_SLOP_PX = 8;
 type TerminalTouch = {
  pointerId: number;
  startX: number;
  startY: number;
  moved: boolean;
 };
 // polyfill for testing in browsers that don't support crypto.randomUUID()
 const thing = () =>
  (String(1e7) + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c: string) => {
    const num = Number(c);
    return (
      num ^
      (window.crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (num / 4)))
    ).toString(16);
  });
 function terminalOperatorId(): string {
  // Session storage survives route unmounts but remains scoped to this browser
  // tab. The ID coordinates attachment ownership; API authentication remains
  // the security boundary.
  const remembered = window.sessionStorage.getItem(TERMINAL_OPERATOR_KEY);
  if (remembered) return remembered;
  const created = window.crypto.randomUUID?.() ?? thing();
  window.sessionStorage.setItem(TERMINAL_OPERATOR_KEY, created);
  return created;
 }
 function websocketUrl(path: string): string {
  const scheme = window.location.protocol === "https:" ? "wss:" : "ws:";
  return `${scheme}//${window.location.host}${path}`;
 }
 export function TerminalPage({
  agents,
  selectedAgentId,
  onSelectAgent,
 }: Props) {
  const pageRef = useRef<HTMLElement>(null);
  const hostRef = useRef<HTMLDivElement>(null);
  const terminalRef = useRef<XTerm | null>(null);
  const fitRef = useRef<FitAddon | null>(null);
  const socketRef = useRef<WebSocket | null>(null);
  const activeSessionRef = useRef<TerminalSession | null>(null);
  const selectedAgentIdRef = useRef(selectedAgentId);
  const lastTerminalSizeRef = useRef({ rows: 0, cols: 0 });
  const modifiersRef = useRef<TerminalModifiers>(NO_TERMINAL_MODIFIERS);
  const terminalTouchRef = useRef<TerminalTouch | null>(null);
  const terminalInputFocusedBeforeAccessoryRef = useRef(false);
  const [sessions, setSessions] = useState<TerminalSession[]>([]);
  const [session, setSession] = useState<TerminalSession | null>(null);
  const [connection, setConnection] = useState<TerminalConnectionState>("idle");
  const [sessionTitles, setSessionTitles] = useState<Record<string, string>>(
    {},
  );
  const [terminalFontFamily, setTerminalFontFamily] = useState<string>();
  const [terminalFontSize, setTerminalFontSize] = useState(
    DEFAULT_TERMINAL_FONT_SIZE,
  );
  const [nowUnix, setNowUnix] = useState(() => Math.floor(Date.now() / 1000));
  const [modifiers, setModifiers] = useState<TerminalModifiers>(
    NO_TERMINAL_MODIFIERS,
  );
  const [accessoriesOpen, setAccessoriesOpen] = useState(
    () => window.matchMedia("(pointer: coarse), (max-width: 640px)").matches,
  );
  const [operatorId] = useState(terminalOperatorId);
  useEffect(() => {
    const clock = window.setInterval(
      () => setNowUnix(Math.floor(Date.now() / 1000)),
      30_000,
    );
    return () => window.clearInterval(clock);
  }, []);
  activeSessionRef.current = session;
  selectedAgentIdRef.current = selectedAgentId;
  const selectedAgent = agents.find(
    (agent) => agent.agent_id === selectedAgentId,
  );
  const selectedAgentSessionCount = sessions.filter(
    (item) => item.agent_id === selectedAgentId,
  ).length;
  const selectedAgentSessionLimit = Math.max(
    1,
    selectedAgent?.capability_options?.terminal?.max_sessions ?? 2,
  );
  const agentAtSessionLimit =
    selectedAgentSessionCount >= selectedAgentSessionLimit;
  const canRequestStart = Boolean(
    selectedAgent?.connected &&
    selectedAgent.capabilities.includes("terminal") &&
    connection !== "connecting",
  );
  const terminalInputReady = connection === "ready";
  const detachTransport = useCallback(() => {
    const socket = socketRef.current;
    socketRef.current = null;
    socket?.close();
  }, []);
  const writeTerminalData = useCallback(
    (data: string, consumeModifiers = false) => {
      const socket = socketRef.current;
      if (socket?.readyState !== WebSocket.OPEN) return;
      const activeModifiers = modifiersRef.current;
      const output = consumeModifiers
        ? applyTerminalModifiers(data, activeModifiers)
        : data;
      socket.send(new TextEncoder().encode(output));
      if (consumeModifiers && (activeModifiers.ctrl || activeModifiers.meta)) {
        modifiersRef.current = NO_TERMINAL_MODIFIERS;
        setModifiers(NO_TERMINAL_MODIFIERS);
      }
    },
    [],
  );
  const toggleModifier = useCallback((modifier: keyof TerminalModifiers) => {
    setModifiers((current) => {
      const next = { ...current, [modifier]: !current[modifier] };
      modifiersRef.current = next;
      return next;
    });
    window.requestAnimationFrame(() => terminalRef.current?.focus());
  }, []);
  const copyTerminalText = useCallback(async () => {
    const terminal = terminalRef.current;
    if (!terminal) return;
    const text = terminal.hasSelection()
      ? terminal.getSelection()
      : visibleTerminalText(terminal);
    if (!text) {
      toast.info("Nothing to copy");
      return;
    }
    try {
      await navigator.clipboard.writeText(text);
      toast.success(
        terminal.hasSelection() ? "Selection copied" : "Visible screen copied",
      );
    } catch (error) {
      toast.error("Clipboard access was denied", {
        description: String(error),
      });
    }
  }, []);
  const pasteTerminalText = useCallback(async () => {
    try {
      const text = await navigator.clipboard.readText();
      if (text) writeTerminalData(text);
      terminalRef.current?.focus();
    } catch (error) {
      toast.error("Clipboard access was denied", {
        description: String(error),
      });
    }
  }, [writeTerminalData]);
  const writeAccessoryKey = useCallback(
    (data: string) => {
      writeTerminalData(data);
      window.requestAnimationFrame(() => terminalRef.current?.focus());
    },
    [writeTerminalData],
  );
  const toggleTerminalKeyboard = useCallback(() => {
    const terminal = terminalRef.current;
    if (!terminal) return;
    const blurTerminalInput = () => {
      terminal.textarea?.blur();
      const activeElement = document.activeElement;
      if (
        activeElement instanceof HTMLElement &&
        hostRef.current?.contains(activeElement)
      ) {
        activeElement.blur();
      }
    };
    const shouldHide =
      terminalInputFocusedBeforeAccessoryRef.current ||
      Boolean(hostRef.current?.contains(document.activeElement));
    terminalInputFocusedBeforeAccessoryRef.current = false;
    if (shouldHide) {
      blurTerminalInput();
      // Base UI may restore the previously focused element as its pointer
      // interaction completes. Dismiss the soft keyboard after that cycle too.
      window.requestAnimationFrame(blurTerminalInput);
    } else {
      terminal.focus();
    }
  }, []);
  const sendResize = useCallback(() => {
    const terminal = terminalRef.current;
    const socket = socketRef.current;
    if (!terminal || socket?.readyState !== WebSocket.OPEN) return;
    if (
      lastTerminalSizeRef.current.rows === terminal.rows &&
      lastTerminalSizeRef.current.cols === terminal.cols
    ) {
      return;
    }
    lastTerminalSizeRef.current = {
      rows: terminal.rows,
      cols: terminal.cols,
    };
    socket.send(
      JSON.stringify({
        type: "resize",
        rows: terminal.rows,
        cols: terminal.cols,
      }),
    );
  }, []);
  const changeTerminalFontSize = useCallback(
    (delta: number) => {
      const terminal = terminalRef.current;
      if (!terminal) return;
      const current = terminal.options.fontSize ?? DEFAULT_TERMINAL_FONT_SIZE;
      const next = Math.min(
        MAX_TERMINAL_FONT_SIZE,
        Math.max(MIN_TERMINAL_FONT_SIZE, current + delta),
      );
      if (next === current) return;
      terminal.options.fontSize = next;
      setTerminalFontSize(next);
      window.requestAnimationFrame(() => {
        fitRef.current?.fit();
        sendResize();
      });
    },
    [sendResize],
  );
  const connect = useCallback(
    (nextSession: TerminalSession) => {
      if (!nextSession.attachment_token) {
        throw new Error(
          "Control plane did not issue a terminal attachment token",
        );
      }
      detachTransport();
      setSession(nextSession);
      activeSessionRef.current = nextSession;
      setSessions((current) =>
        mergeTerminalSession(current, {
          ...nextSession,
          operator_attached: true,
        }),
      );
      window.sessionStorage.setItem(
        REMEMBERED_TERMINAL_KEY,
        nextSession.terminal_id,
      );
      setConnection("connecting");
      const socket = new WebSocket(websocketUrl(nextSession.websocket_url));
      socket.binaryType = "arraybuffer";
      socketRef.current = socket;
      socket.onopen = () => {
        socket.send(
          JSON.stringify({
            type: "attach",
            attachment_token: nextSession.attachment_token,
            operator_id: operatorId,
          }),
        );
        fitRef.current?.fit();
        sendResize();
      };
      socket.onmessage = (event) => {
        if (socketRef.current !== socket) return;
        if (typeof event.data !== "string") {
          terminalRef.current?.write(new Uint8Array(event.data as ArrayBuffer));
          return;
        }
        try {
          const control = JSON.parse(event.data) as {
            type: string;
            exit_code?: number | null;
            message?: string;
          };
          if (control.type === "ready") {
            setConnection("ready");
            window.requestAnimationFrame(() => {
              fitRef.current?.fit();
              lastTerminalSizeRef.current = { rows: 0, cols: 0 };
              sendResize();
              terminalRef.current?.focus();
            });
          } else if (control.type === "exited") {
            setConnection("exited");
            terminalRef.current?.writeln(
              `\r\n[process exited${control.exit_code == null ? "" : ` ${control.exit_code}`}]`,
            );
          } else if (control.type === "error") {
            setConnection("exited");
            terminalRef.current?.writeln(
              `\r\n[terminal error: ${control.message ?? "unknown error"}]`,
            );
          }
        } catch {
          terminalRef.current?.writeln("\r\n[invalid terminal control frame]");
        }
      };
      socket.onerror = () => {
        if (socketRef.current !== socket) return;
        terminalRef.current?.writeln("\r\n[terminal transport error]");
      };
      socket.onclose = () => {
        if (socketRef.current !== socket) return;
        socketRef.current = null;
        setSessions((current) =>
          current.map((item) =>
            item.terminal_id === nextSession.terminal_id
              ? { ...item, operator_attached: false }
              : item,
          ),
        );
        setConnection((current) => {
          if (current === "exited") return current;
          return "disconnected";
        });
      };
    },
    [detachTransport, operatorId, sendResize],
  );
  useEffect(() => {
    let cancelled = false;
    void loadTerminalFontFamily().then((fontFamily) => {
      if (!cancelled) setTerminalFontFamily(fontFamily);
    });
    return () => {
      cancelled = true;
    };
  }, []);
  useEffect(() => {
    const viewport = window.visualViewport;
    const updateViewportHeight = () => {
      const height = Math.round(viewport?.height ?? window.innerHeight);
      pageRef.current?.style.setProperty(
        "--terminal-visual-viewport-height",
        `${height}px`,
      );
    };
    updateViewportHeight();
    viewport?.addEventListener("resize", updateViewportHeight);
    viewport?.addEventListener("scroll", updateViewportHeight);
    window.addEventListener("resize", updateViewportHeight);
    return () => {
      viewport?.removeEventListener("resize", updateViewportHeight);
      viewport?.removeEventListener("scroll", updateViewportHeight);
      window.removeEventListener("resize", updateViewportHeight);
    };
  }, []);
  useEffect(() => {
    if (!hostRef.current || !terminalFontFamily) return;
    const terminal = new XTerm({
      cursorBlink: true,
      convertEol: false,
      fontFamily: terminalFontFamily,
      fontSize: DEFAULT_TERMINAL_FONT_SIZE,
      lineHeight: 1.1,
      // xterm uses this width for its internal scrollbar as well as the
      // overview ruler. Reserve a larger touch target on coarse pointers.
      scrollbar: {
        width: window.matchMedia("(pointer: coarse)").matches ? 22 : 16,
      },
      scrollback: 10_000,
      theme: {
        background: "#0b1117",
        foreground: "#e5e7eb",
        cursor: "#6ee7a8",
        scrollbarSliderBackground: "#52617099",
        scrollbarSliderHoverBackground: "#6b7c8dcc",
        scrollbarSliderActiveBackground: "#8294a6",
      },
      allowProposedApi: true, // this for unicode11 addon. FOR SOME reason xtermjs doesnt tell me this in the readme.
    });
    terminal.loadAddon(new Unicode11Addon());
    terminal.unicode.activeVersion = "11";
    terminal.loadAddon(new UnicodeGraphemesAddon());
    terminal.loadAddon(new WebLinksAddon());
    terminal.loadAddon(
      new ImageAddon({
        // // Keep image terminals useful on phones without accepting the addon's
        // // much larger default decode and retained-canvas memory ceilings.
        // pixelLimit: 4 * 1024 * 1024,
        // sixelSizeLimit: 8 * 1024 * 1024,
        // iipSizeLimit: 8 * 1024 * 1024,
        // storageLimit: 32,
      }),
    );
    const fit = new FitAddon();
    terminal.loadAddon(new ClipboardAddon());
    terminal.loadAddon(fit);
    terminal.open(hostRef.current);
    terminal.attachCustomKeyEventHandler((event) => {
      const copiesTerminalSelection =
        event.type === "keydown" &&
        event.ctrlKey &&
        event.shiftKey &&
        event.code === "KeyC";
      if (!copiesTerminalSelection) return true;
      // Chromium reserves Ctrl+Shift+C for DevTools. Other clipboard shortcuts
      // fall through to xterm's native copy/paste event handlers.
      event.preventDefault();
      event.stopPropagation();
      if (terminal.hasSelection()) {
        if (!navigator.clipboard) {
          toast.error("Clipboard access requires HTTPS or localhost");
        } else {
          void navigator.clipboard
            .writeText(terminal.getSelection())
            .catch((error) =>
              toast.error("Clipboard access was denied", {
                description: String(error),
              }),
            );
        }
      }
      return false;
    });
    const titleChange = terminal.onTitleChange((title) => {
      const terminalId = activeSessionRef.current?.terminal_id;
      if (!terminalId) return;
      const normalized = title.trim();
      setSessionTitles((current) => {
        if (current[terminalId] === normalized) return current;
        if (!normalized) {
          const next = { ...current };
          delete next[terminalId];
          return next;
        }
        return { ...current, [terminalId]: normalized };
      });
    });
    fit.fit();
    terminalRef.current = terminal;
    fitRef.current = fit;
    async function restoreTerminalSession() {
      try {
        const listed = await listTerminals();
        if (cancelled) return;
        setSessions(orderTerminalSessions(listed));
        const rememberedId = window.sessionStorage.getItem(
          REMEMBERED_TERMINAL_KEY,
        );
        const candidates = restoreCandidates(
          listed,
          rememberedId,
          selectedAgentIdRef.current,
        );
        for (const candidate of candidates) {
          setConnection("connecting");
          try {
            const attached = await attachTerminal(
              candidate.terminal_id,
              operatorId,
            );
            if (cancelled) return;
            terminal.reset();
            connect(attached);
            return;
          } catch (error) {
            if (
              !(error instanceof APIError) ||
              error.code !== "terminal_operator_already_attached"
            ) {
              throw error;
            }
          }
        }
        setConnection("idle");
      } catch (error) {
        if (cancelled) return;
        setConnection("idle");
        toast.error("Could not restore terminal session", {
          description: String(error),
        });
      }
    }
    let cancelled = false;
    const input = terminal.onData((data) => writeTerminalData(data, true));
    let resizeFrame = 0;
    let lastHostWidth = 0;
    let lastHostHeight = 0;
    const resizeObserver = new ResizeObserver(([entry]) => {
      const width = Math.round(entry.contentRect.width);
      const height = Math.round(entry.contentRect.height);
      if (width === lastHostWidth && height === lastHostHeight) return;
      lastHostWidth = width;
      lastHostHeight = height;
      window.cancelAnimationFrame(resizeFrame);
      resizeFrame = window.requestAnimationFrame(() => {
        fit.fit();
        sendResize();
      });
    });
    resizeObserver.observe(hostRef.current);
    void restoreTerminalSession();
    const sessionRefresh = window.setInterval(() => {
      void listTerminals()
        .then((listed) => {
          if (!cancelled) {
            setSessions((current) =>
              reconcileTerminalSessions(current, listed),
            );
          }
        })
        .catch(() => {
          // The attached terminal transport remains authoritative while a
          // background list refresh is temporarily unavailable.
        });
    }, 5000);
    return () => {
      cancelled = true;
      input.dispose();
      titleChange.dispose();
      resizeObserver.disconnect();
      window.cancelAnimationFrame(resizeFrame);
      window.clearInterval(sessionRefresh);
      detachTransport();
      terminal.dispose();
      terminalRef.current = null;
      fitRef.current = null;
    };
  }, [
    connect,
    detachTransport,
    sendResize,
    terminalFontFamily,
    writeTerminalData,
  ]);
  async function start() {
    if (!selectedAgentId || !terminalRef.current) return;
    if (agentAtSessionLimit) {
      toast.error("Terminal session limit reached", {
        description: `${selectedAgent ? displayAgentLabel(selectedAgent) : selectedAgentId} already reached the active session limit. Close one before opening another.`,
      });
      return;
    }
    const previousSession = activeSessionRef.current;
    detachTransport();
    if (previousSession) {
      setSessions((current) =>
        current.map((item) =>
          item.terminal_id === previousSession.terminal_id
            ? { ...item, operator_attached: false }
            : item,
        ),
      );
    }
    setConnection("connecting");
    terminalRef.current.reset();
    try {
      fitRef.current?.fit();
      const created = await createTerminal(
        selectedAgentId,
        terminalRef.current.rows,
        terminalRef.current.cols,
      );
      connect(created);
    } catch (error) {
      setSession(null);
      activeSessionRef.current = null;
      setConnection("idle");
      toast.error("Could not start terminal", { description: String(error) });
    }
  }
  async function activateSession(nextSession: TerminalSession) {
    if (nextSession.terminal_id === session?.terminal_id) return;
    if (nextSession.operator_attached) return;
    const previousSession = activeSessionRef.current;
    detachTransport();
    if (previousSession) {
      setSessions((current) =>
        current.map((item) =>
          item.terminal_id === previousSession.terminal_id
            ? { ...item, operator_attached: false }
            : item,
        ),
      );
    }
    setSession(null);
    activeSessionRef.current = null;
    setConnection("connecting");
    terminalRef.current?.reset();
    window.sessionStorage.setItem(
      REMEMBERED_TERMINAL_KEY,
      nextSession.terminal_id,
    );
    try {
      const attached = await attachTerminal(
        nextSession.terminal_id,
        operatorId,
      );
      connect(attached);
    } catch (error) {
      setConnection("idle");
      toast.error("Could not attach terminal session", {
        description: String(error),
      });
      void listTerminals()
        .then((listed) =>
          setSessions((current) => reconcileTerminalSessions(current, listed)),
        )
        .catch(() => undefined);
    }
  }
  async function reconnect() {
    if (!session) return;
    detachTransport();
    try {
      terminalRef.current?.reset();
      setConnection("connecting");
      const attached = await attachTerminal(session.terminal_id, operatorId);
      connect(attached);
    } catch (error) {
      setConnection("disconnected");
      toast.error("Terminal session is no longer available", {
        description: String(error),
      });
    }
  }
  async function closeSession(closingSession: TerminalSession) {
    const closingId = closingSession.terminal_id;
    const closesActiveSession =
      closingId === activeSessionRef.current?.terminal_id;
    const remaining = sessions.filter((item) => item.terminal_id !== closingId);
    const fallback = remaining.find((item) => !item.operator_attached);
    if (closesActiveSession) {
      if (socketRef.current?.readyState === WebSocket.OPEN) {
        socketRef.current.send(JSON.stringify({ type: "close" }));
      }
      detachTransport();
    }
    try {
      await closeTerminal(closingId);
    } catch (error) {
      toast.error("Terminal cleanup failed", { description: String(error) });
      void listTerminals()
        .then((listed) =>
          setSessions((current) => reconcileTerminalSessions(current, listed)),
        )
        .catch(() => undefined);
      return;
    }
    setSessions((current) =>
      current.filter((item) => item.terminal_id !== closingId),
    );
    setSessionTitles((current) => {
      const next = { ...current };
      delete next[closingId];
      return next;
    });
    if (window.sessionStorage.getItem(REMEMBERED_TERMINAL_KEY) === closingId) {
      window.sessionStorage.removeItem(REMEMBERED_TERMINAL_KEY);
    }
    if (closesActiveSession) {
      setSession(null);
      activeSessionRef.current = null;
      setConnection("idle");
      // xterm.clear() deliberately preserves the active cursor line. Closing
      // a session should discard its complete screen and terminal modes.
      terminalRef.current?.reset();
      if (fallback) void activateSession(fallback);
    }
  }
  return (
    <section
      className="terminal-page"
      aria-label="Remote terminal"
      ref={pageRef}
    >
      <header className="terminal-toolbar">
        <div className="terminal-heading">
          <Terminal className="size-5 text-primary" aria-hidden />
          <h1>Remote Terminal</h1>
        </div>
        <div className="terminal-controls">
          <AgentSelector
            agents={agents.filter(
              (agent) =>
                agent.connected && agent.capabilities.includes("terminal"),
            )}
            value={selectedAgentId}
            onChange={onSelectAgent}
            disabled={connection === "connecting"}
            className="w-full min-w-0 sm:w-64"
          />
        </div>
      </header>
      {!selectedAgent && connection === "idle" ? (
        <p className="terminal-notice">
          No connected terminal-capable agent is selected.
        </p>
      ) : selectedAgent && !selectedAgent.capabilities.includes("terminal") ? (
        <p className="terminal-notice">
          This agent has not enabled remote terminal capability.
        </p>
      ) : null}
      <div className="terminal-frame">
        <div className="terminal-framebar">
          <TerminalSessionTabs
            agents={agents}
            sessions={sessions}
            activeTerminalId={session?.terminal_id}
            connection={connection}
            sessionTitles={sessionTitles}
            nowUnix={nowUnix}
            canRequestStart={canRequestStart}
            agentAtSessionLimit={agentAtSessionLimit}
            selectedAgentSessionLimit={selectedAgentSessionLimit}
            onActivate={(item) => void activateSession(item)}
            onClose={(item) => void closeSession(item)}
            onStart={() => void start()}
          />
          <div className="terminal-frame-actions">
            <Badge
              variant="outline"
              className="terminal-status"
              data-state={connection}
            >
              <span aria-hidden />
              {connection}
            </Badge>
            {connection === "disconnected" ? (
              <Button
                type="button"
                size="sm"
                variant="ghost"
                onClick={reconnect}
              >
                <RotateCcw className="size-4" aria-hidden />
                Reconnect
              </Button>
            ) : null}
            <Tooltip>
              <TooltipTrigger>
                <Button
                  type="button"
                  size="icon"
                  variant="ghost"
                  className="terminal-accessories-toggle"
                  data-active={accessoriesOpen || undefined}
                  aria-label={
                    accessoriesOpen
                      ? "Hide terminal controls"
                      : "Show terminal controls"
                  }
                  aria-expanded={accessoriesOpen}
                  onClick={() => setAccessoriesOpen((current) => !current)}
                >
                  <Keyboard className="size-4" aria-hidden />
                </Button>
              </TooltipTrigger>
              <TooltipContent>Terminal controls</TooltipContent>
            </Tooltip>
            <Tooltip>
              <TooltipTrigger>
                <Button
                  type="button"
                  size="icon"
                  variant="ghost"
                  disabled={connection === "idle"}
                  aria-label="Clear terminal"
                  onClick={() => terminalRef.current?.clear()}
                >
                  <Eraser className="size-4" aria-hidden />
                </Button>
              </TooltipTrigger>
              <TooltipContent>Clear terminal</TooltipContent>
            </Tooltip>
          </div>
        </div>
        {accessoriesOpen ? (
          <TerminalAccessoryBar
            inputReady={terminalInputReady}
            modifiers={modifiers}
            fontSize={terminalFontSize}
            onRememberInputFocus={() => {
              terminalInputFocusedBeforeAccessoryRef.current = Boolean(
                hostRef.current?.contains(document.activeElement),
              );
            }}
            onToggleModifier={toggleModifier}
            onWriteKey={writeAccessoryKey}
            onScrollPages={(pages) => terminalRef.current?.scrollPages(pages)}
            onCopy={() => void copyTerminalText()}
            onPaste={() => void pasteTerminalText()}
            onToggleKeyboard={toggleTerminalKeyboard}
            onChangeFontSize={changeTerminalFontSize}
          />
        ) : null}
        <div
          className="terminal-surface"
          ref={hostRef}
          onPointerDown={(event) => {
            if (event.pointerType !== "touch") {
              terminalRef.current?.focus();
              return;
            }
            terminalTouchRef.current = {
              pointerId: event.pointerId,
              startX: event.clientX,
              startY: event.clientY,
              moved: false,
            };
          }}
          onPointerMove={(event) => {
            const touch = terminalTouchRef.current;
            if (!touch || touch.pointerId !== event.pointerId || touch.moved) {
              return;
            }
            touch.moved =
              Math.hypot(
                event.clientX - touch.startX,
                event.clientY - touch.startY,
              ) > TERMINAL_TOUCH_SLOP_PX;
          }}
          onPointerUp={(event) => {
            const touch = terminalTouchRef.current;
            terminalTouchRef.current = null;
            if (
              touch?.pointerId === event.pointerId &&
              !touch.moved &&
              event.pointerType === "touch"
            ) {
              terminalRef.current?.focus();
            }
          }}
          onPointerCancel={() => {
            terminalTouchRef.current = null;
          }}
        />
      </div>
    </section>
  );
 }
@@ -118,7 +118,7 @@ export function TokensPage() {
  return (
    <section className="grid gap-4 xl:grid-cols-2">
      <Card>
-        <CardHeader className="flex flex-row items-start justify-between gap-3 space-y-0">
+        <CardHeader className="flex flex-row items-start justify-between gap-3 gap-y-0">
          <div>
            <CardTitle className="flex items-center gap-2">
              <Key className="size-5 text-primary" />
@@ -219,9 +219,13 @@ export function TokensPage() {
                </Button>
              </div>
              {useCustom && (
-                <label className="mt-2 grid gap-1 text-sm text-muted-foreground">
+                <label
                  htmlFor="token-custom-ttl"
                  className="mt-2 grid gap-1 text-sm text-muted-foreground"
                >
                  <span>TTL (seconds)</span>
                  <Input
                    id="token-custom-ttl"
                    type="number"
                    min={1}
                    value={customTtl}
@@ -101,7 +101,10 @@ export function WakeToolsPage({
          </CardDescription>
        </CardHeader>
        <CardContent className="space-y-4">
-          <label className="grid gap-1.5 text-sm text-muted-foreground">
+          <label
            htmlFor="wake-agent"
            className="grid gap-1.5 text-sm text-muted-foreground"
          >
            <span>Agent</span>
            <AgentSelector
              agents={agents}
@@ -111,14 +114,17 @@ export function WakeToolsPage({
          </label>
          <form onSubmit={handleWake} className="grid gap-3">
-            <label className="grid gap-1.5 text-sm text-muted-foreground">
+            <label
              htmlFor="wake-target"
              className="grid gap-1.5 text-sm text-muted-foreground"
            >
              <span>Target</span>
              <Input
                id="wake-target"
                value={target}
                onChange={(e) => setTarget(e.target.value)}
                placeholder="bedroom-pc, 192.168.1.100, or aa:bb:cc:dd:ee:ff"
                disabled={busy}
                autoFocus
              />
            </label>
            <Button
@@ -134,7 +140,7 @@ export function WakeToolsPage({
      </Card>
      <Card>
-        <CardHeader className="flex flex-row items-center justify-between gap-2 space-y-0">
+        <CardHeader className="flex flex-row items-center justify-between gap-2 gap-y-0">
          <CardTitle>Recent Wakes</CardTitle>
          <Button
            variant="outline"
@@ -147,10 +153,10 @@ export function WakeToolsPage({
        <CardContent>
          {recentWakes.length > 0 ? (
            <div className="grid gap-0">
-              {recentWakes.map((event, idx) => (
+              {recentWakes.map((event, i) => (
                <div
-                  className={`flex items-start justify-between gap-3 py-2.5 ${idx < recentWakes.length - 1 ? "border-b border-border/50" : ""}`}
+                  className={`flex items-start justify-between gap-3 py-2.5 ${i < recentWakes.length - 1 ? "border-b border-border/50" : ""}`}
-                  key={`${event.ts}-${idx}`}
+                  key={`${event.ts}-${event.target}-${event.agentId}`}
                >
                  <div className="min-w-0">
                    <div className="flex items-center gap-2">
@@ -1,5 +1,5 @@
-import { useEffect, useMemo, useState } from "react";
+import { useMemo, useState } from "react";
-import { Minus, Plus, Zap } from "lucide-react";
+import { Copy, Minus, Plus, Zap } from "lucide-react";
 import { toast } from "sonner";
 import {
@@ -8,6 +8,7 @@ import {
  detachDeviceIdentifier,
  mergeKnownDevice,
  type FleetDevice,
  type FleetDeviceEndpoint,
  type KnownDevice,
 } from "@/api";
 import { Badge } from "@/components/ui/badge";
@@ -29,7 +30,13 @@ import {
 } from "@/components/ui/select";
 import { Separator } from "@/components/ui/separator";
 import { DetailBlock, PresenceBadge } from "@/pages/fleet/FleetComponents";
-import { agentLabel, identifiersFor, routeLabel } from "@/pages/fleet/utils";
+import {
  agentLabel,
  formatSeen,
  identifiersFor,
  presenceRank,
  routeLabel,
 } from "@/pages/fleet/utils";
 type Props = {
  device: FleetDevice | null;
@@ -52,24 +59,16 @@ export function FleetDeviceDetailsDialog({
  onCopy,
  onChanged,
 }: Props) {
-  const [displayName, setDisplayName] = useState("");
+  const [displayName, setDisplayName] = useState(device?.display_name ?? "");
  const [targetDeviceId, setTargetDeviceId] = useState("");
-  const [routeId, setRouteId] = useState("");
+  const [routeId, setRouteId] = useState(
    device?.recommended_route?.route_id ?? "",
  );
  const [addKind, setAddKind] = useState<"mac" | "ip">("mac");
  const [addValue, setAddValue] = useState("");
  const [error, setError] = useState("");
  const [actionBusy, setActionBusy] = useState(false);
  useEffect(() => {
    setDisplayName(device?.display_name ?? "");
    setTargetDeviceId("");
    setRouteId(device?.recommended_route?.route_id ?? "");
    setAddKind("mac");
    setAddValue("");
    setError("");
    setActionBusy(false);
  }, [device]);
  const rowIdentifiers = device ? identifiersFor(device) : [];
  // Resolve the full KnownDevice object if this fleet row is known
@@ -191,7 +190,7 @@ export function FleetDeviceDetailsDialog({
  return (
    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="max-h-[92vh] overflow-auto sm:max-w-3xl">
+      <DialogContent className="max-h-[92vh] overflow-auto sm:max-w-4xl">
        <DialogHeader>
          <div className="flex min-w-0 items-start justify-between gap-3 pr-8">
            <div className="min-w-0">
@@ -233,6 +232,42 @@ export function FleetDeviceDetailsDialog({
        <Separator />
        <div className="grid gap-2">
          <div className="flex items-center justify-between gap-2">
            <h3 className="text-sm font-medium">Endpoints</h3>
            <Badge variant="outline">{device.endpoints.length}</Badge>
          </div>
          {device.endpoints.length ? (
            <div className="grid gap-1.5">
              <div className="hidden grid-cols-[minmax(0,1.3fr)_minmax(0,1fr)_8rem_2rem] items-center gap-2 px-3 py-1.5 text-xs font-medium text-muted-foreground sm:grid">
                <span>Source</span>
                <span>Target</span>
                <span className="text-right">Last seen</span>
                <span />
              </div>
              {[...device.endpoints]
                .sort((a, b) => {
                  const p = presenceRank(b.presence) - presenceRank(a.presence);
                  if (p !== 0) return p;
                  return (b.last_seen_unix ?? 0) - (a.last_seen_unix ?? 0);
                })
                .map((endpoint, index) => (
                  <EndpointRow
                    key={`${endpoint.agent_id}:${endpoint.source}:${endpoint.mac ?? ""}:${endpoint.ip ?? ""}:${index}`}
                    endpoint={endpoint}
                    onCopy={onCopy}
                  />
                ))}
            </div>
          ) : (
            <p className="rounded-md border bg-muted/30 p-3 text-sm text-muted-foreground">
              No endpoint evidence reported.
            </p>
          )}
        </div>
        <Separator />
        {/* ── Wake route ── */}
        <div className="grid gap-2">
          <div className="flex items-center justify-between gap-2">
@@ -279,7 +314,7 @@ export function FleetDeviceDetailsDialog({
                <span className="font-medium">{fullKnown.display_name}</span>
                {fullKnown.notes && (
                  <span className="text-muted-foreground">
-                    — {fullKnown.notes}
+                    : {fullKnown.notes}
                  </span>
                )}
              </div>
@@ -521,3 +556,52 @@ export function FleetDeviceDetailsDialog({
    </Dialog>
  );
 }
 function EndpointRow({
  endpoint,
  onCopy,
 }: {
  endpoint: FleetDeviceEndpoint;
  onCopy: (label: string, value: string) => void;
 }) {
  const target = [endpoint.mac, endpoint.ip].filter(Boolean).join(" / ");
  const location = [endpoint.interface, endpoint.hostname]
    .filter(Boolean)
    .join(" / ");
  return (
    <div className="grid gap-3 rounded-md border bg-card px-3 py-2.5 text-sm sm:grid-cols-[minmax(0,1.3fr)_minmax(0,1fr)_8rem_2rem] sm:items-center sm:gap-2">
      <div className="min-w-0">
        <div className="flex min-w-0 flex-wrap items-center gap-1.5">
          <PresenceBadge presence={endpoint.presence} />
          <Badge variant="secondary">{endpoint.source.replace("_", " ")}</Badge>
        </div>
        <p className="mt-1 truncate text-xs text-muted-foreground">
          {agentLabel(endpoint.agent_id, endpoint.nickname)}
          {endpoint.connected ? " (connected)" : " (offline)"}
        </p>
      </div>
      <div className="min-w-0">
        <p className="truncate font-mono text-xs">{target || "-"}</p>
        <p className="mt-0.5 truncate text-xs text-muted-foreground">
          {location || "No interface or hostname"}
        </p>
      </div>
      <span className="whitespace-nowrap text-right text-xs text-muted-foreground">
        {formatSeen(endpoint.last_seen_unix)}
      </span>
      <div className="flex justify-end">
        {target && (
          <Button
            variant="ghost"
            size="icon-sm"
            onClick={() => onCopy("Endpoint", target)}
            aria-label={`Copy endpoint ${target}`}
          >
            <Copy className="size-3.5" />
          </Button>
        )}
      </div>
    </div>
  );
 }
@@ -14,8 +14,8 @@ export const presenceFilters = [
  "all",
  "online",
  "likely_online",
  "unknown",
  "offline",
  "unknown",
 ] as const;
 export const knownFilters: KnownFilter[] = ["all", "known", "unknown"];
@@ -40,8 +40,8 @@ export function formatSeen(value: number | null): string {
 export function presenceRank(presence: string): number {
  if (presence === "online") return 4;
  if (presence === "likely_online") return 3;
-  if (presence === "unknown") return 2;
+  if (presence === "offline") return 2;
-  if (presence === "offline") return 1;
+  if (presence === "unknown") return 1;
  return 0;
 }
@@ -60,7 +60,7 @@ export function agentLabel(agentId: string, nickname?: string | null): string {
 }
 export function routeLabel(route: FleetWakeRoute): string {
-  const status = route.connected ? "connected" : "offline";
+  const status = route.connected ? "connected" : "agent offline";
  const target = route.mac
    ? `${route.mac}${route.ip ? ` / ${route.ip}` : ""}`
    : (route.ip ?? "-");
@@ -0,0 +1,259 @@
 import {
  ArrowDown,
  ArrowLeft,
  ArrowRight,
  ArrowUp,
  ClipboardCopy,
  ClipboardPaste,
  Keyboard,
  ZoomIn,
  ZoomOut,
 } from "lucide-react";
 import type { LucideIcon } from "lucide-react";
 import type { MouseEvent, PointerEvent } from "react";
 import { Button } from "@/components/ui/button";
 import type { TerminalModifiers } from "@/pages/terminal/sessionUtils";
 export const MIN_TERMINAL_FONT_SIZE = 10;
 export const MAX_TERMINAL_FONT_SIZE = 22;
 type Props = {
  inputReady: boolean;
  modifiers: TerminalModifiers;
  fontSize: number;
  onRememberInputFocus: () => void;
  onToggleModifier: (modifier: keyof TerminalModifiers) => void;
  onWriteKey: (data: string) => void;
  onScrollPages: (pages: number) => void;
  onCopy: () => void;
  onPaste: () => void;
  onToggleKeyboard: () => void;
  onChangeFontSize: (delta: number) => void;
 };
 const CONTROL_KEYS: ReadonlyArray<
  readonly [label: string, sequence: string, title: string]
 > = [
  ["^C", "\x03", "Interrupt"],
  ["^U", "\x15", "Clear input line"],
  ["^A", "\x01", "Start of line"],
  ["^E", "\x05", "End of line"],
 ];
 const ARROW_KEYS: ReadonlyArray<
  readonly [label: string, sequence: string, icon: LucideIcon]
 > = [
  ["Left arrow", "\x1b[D", ArrowLeft],
  ["Down arrow", "\x1b[B", ArrowDown],
  ["Up arrow", "\x1b[A", ArrowUp],
  ["Right arrow", "\x1b[C", ArrowRight],
 ];
 function preserveInputFocus(
  event: PointerEvent<HTMLDivElement> | MouseEvent<HTMLDivElement>,
  onRememberInputFocus: () => void,
 ) {
  if (event.target instanceof Element && event.target.closest("button")) {
    onRememberInputFocus();
    event.preventDefault();
  }
 }
 export function TerminalAccessoryBar({
  inputReady,
  modifiers,
  fontSize,
  onRememberInputFocus,
  onToggleModifier,
  onWriteKey,
  onScrollPages,
  onCopy,
  onPaste,
  onToggleKeyboard,
  onChangeFontSize,
 }: Props) {
  return (
    <div
      className="terminal-accessories"
      role="toolbar"
      aria-label="Terminal controls"
      onPointerDownCapture={(event) => {
        // Preserve whether xterm was focused before the button library moves
        // focus. The keyboard button consumes this to show or hide mobile IME.
        preserveInputFocus(event, onRememberInputFocus);
      }}
      onMouseDownCapture={(event) => {
        // Firefox can take the mouse-event path without emitting pointerdown.
        preserveInputFocus(event, onRememberInputFocus);
      }}
    >
      <div className="terminal-accessory-group">
        <Button
          type="button"
          size="sm"
          variant="ghost"
          className="terminal-key"
          data-active={modifiers.ctrl || undefined}
          aria-pressed={modifiers.ctrl}
          disabled={!inputReady}
          onClick={() => onToggleModifier("ctrl")}
        >
          Ctrl
        </Button>
        <Button
          type="button"
          size="sm"
          variant="ghost"
          className="terminal-key"
          data-active={modifiers.meta || undefined}
          aria-pressed={modifiers.meta}
          disabled={!inputReady}
          onClick={() => onToggleModifier("meta")}
        >
          Meta
        </Button>
        <Button
          type="button"
          size="sm"
          variant="ghost"
          className="terminal-key"
          disabled={!inputReady}
          onClick={() => onWriteKey("\x1b")}
        >
          Esc
        </Button>
        <Button
          type="button"
          size="sm"
          variant="ghost"
          className="terminal-key"
          disabled={!inputReady}
          onClick={() => onWriteKey("\t")}
        >
          Tab
        </Button>
      </div>
      <div className="terminal-accessory-group">
        {CONTROL_KEYS.map(([label, sequence, title]) => (
          <Button
            key={label}
            type="button"
            size="sm"
            variant="ghost"
            className="terminal-key terminal-key--control"
            aria-label={title}
            title={title}
            disabled={!inputReady}
            onClick={() => onWriteKey(sequence)}
          >
            {label}
          </Button>
        ))}
      </div>
      <div className="terminal-accessory-group">
        {ARROW_KEYS.map(([label, sequence, Icon]) => (
          <Button
            key={label}
            type="button"
            size="icon"
            variant="ghost"
            className="terminal-key terminal-key--icon"
            aria-label={label}
            disabled={!inputReady}
            onClick={() => onWriteKey(sequence)}
          >
            <Icon className="size-4" aria-hidden />
          </Button>
        ))}
      </div>
      <div className="terminal-accessory-group">
        <Button
          type="button"
          size="sm"
          variant="ghost"
          className="terminal-key terminal-key--wide"
          onClick={() => onScrollPages(-1)}
        >
          PgUp
        </Button>
        <Button
          type="button"
          size="sm"
          variant="ghost"
          className="terminal-key terminal-key--wide"
          onClick={() => onScrollPages(1)}
        >
          PgDn
        </Button>
      </div>
      <div className="terminal-accessory-group">
        <Button
          type="button"
          size="icon"
          variant="ghost"
          className="terminal-key terminal-key--icon"
          aria-label="Copy selection or visible screen"
          title="Copy selection or visible screen"
          onClick={onCopy}
        >
          <ClipboardCopy className="size-4" aria-hidden />
        </Button>
        <Button
          type="button"
          size="icon"
          variant="ghost"
          className="terminal-key terminal-key--icon"
          aria-label="Paste"
          title="Paste"
          disabled={!inputReady}
          onClick={onPaste}
        >
          <ClipboardPaste className="size-4" aria-hidden />
        </Button>
        <Button
          type="button"
          size="icon"
          variant="ghost"
          className="terminal-key terminal-key--icon"
          aria-label="Toggle terminal keyboard"
          title="Toggle terminal keyboard"
          disabled={!inputReady}
          onClick={onToggleKeyboard}
        >
          <Keyboard className="size-4" aria-hidden />
        </Button>
      </div>
      <div className="terminal-accessory-group terminal-font-controls">
        <Button
          type="button"
          size="icon"
          variant="ghost"
          className="terminal-key terminal-key--icon"
          disabled={fontSize <= MIN_TERMINAL_FONT_SIZE}
          aria-label="Decrease terminal text size"
          onClick={() => onChangeFontSize(-1)}
        >
          <ZoomOut className="size-4" aria-hidden />
        </Button>
        <output aria-label="Terminal text size">{fontSize}</output>
        <Button
          type="button"
          size="icon"
          variant="ghost"
          className="terminal-key terminal-key--icon"
          disabled={fontSize >= MAX_TERMINAL_FONT_SIZE}
          aria-label="Increase terminal text size"
          onClick={() => onChangeFontSize(1)}
        >
          <ZoomIn className="size-4" aria-hidden />
        </Button>
      </div>
    </div>
  );
 }
@@ -0,0 +1,189 @@
 import { Plus, Terminal, X } from "lucide-react";
 import type { Agent, TerminalSession } from "@/api";
 import { displayAgentLabel } from "@/components/AgentSelector";
 import { Button } from "@/components/ui/button";
 import {
  Tooltip,
  TooltipContent,
  TooltipTrigger,
 } from "@/components/ui/tooltip";
 import type { TerminalConnectionState } from "@/pages/terminal/sessionUtils";
 type Props = {
  agents: Agent[];
  sessions: TerminalSession[];
  activeTerminalId?: string;
  connection: TerminalConnectionState;
  sessionTitles: Record<string, string>;
  nowUnix: number;
  canRequestStart: boolean;
  agentAtSessionLimit: boolean;
  selectedAgentSessionLimit: number;
  onActivate: (session: TerminalSession) => void;
  onClose: (session: TerminalSession) => void;
  onStart: () => void;
 };
 function terminalCreatedTime(createdAtUnix: number): string {
  return new Date(createdAtUnix * 1000).toLocaleTimeString([], {
    hour: "2-digit",
    minute: "2-digit",
  });
 }
 function terminalTimestamp(timestampUnix: number): string {
  return new Date(timestampUnix * 1000).toLocaleString();
 }
 function terminalExpiryDisplay(
  expiresAtUnix: number | null | undefined,
  nowUnix: number,
 ): { label: string; warning: boolean } | null {
  if (expiresAtUnix == null) return null;
  const remainingSeconds = expiresAtUnix - nowUnix;
  if (remainingSeconds <= 0) return { label: "expired", warning: true };
  if (remainingSeconds < 60) return { label: "<1m left", warning: true };
  if (remainingSeconds < 3600) {
    return {
      label: `${Math.floor(remainingSeconds / 60)}m left`,
      warning: remainingSeconds < 10 * 60,
    };
  }
  if (remainingSeconds < 24 * 3600) {
    return {
      label: `${Math.floor(remainingSeconds / 3600)}h left`,
      warning: false,
    };
  }
  return {
    label: `${Math.floor(remainingSeconds / (24 * 3600))}d left`,
    warning: false,
  };
 }
 export function TerminalSessionTabs({
  agents,
  sessions,
  activeTerminalId,
  connection,
  sessionTitles,
  nowUnix,
  canRequestStart,
  agentAtSessionLimit,
  selectedAgentSessionLimit,
  onActivate,
  onClose,
  onStart,
 }: Props) {
  return (
    <div className="terminal-tabs">
      <div
        className="terminal-tab-list"
        role="tablist"
        aria-label="Terminal sessions"
      >
        {sessions.length === 0 ? (
          <div className="terminal-session-label">
            <Terminal className="size-4" aria-hidden />
            <span>No active session</span>
          </div>
        ) : (
          sessions.map((item) => {
            const agent = agents.find(
              (candidate) => candidate.agent_id === item.agent_id,
            );
            const active = item.terminal_id === activeTerminalId;
            const locked = item.operator_attached && !active;
            const agentLabel = agent ? displayAgentLabel(agent) : item.agent_id;
            const sessionTitle = sessionTitles[item.terminal_id];
            const tabLabel = sessionTitle
              ? `${agentLabel} · ${sessionTitle}`
              : agentLabel;
            const expiry = terminalExpiryDisplay(item.expires_at_unix, nowUnix);
            const timingTitle =
              item.expires_at_unix != null
                ? `Expires ${terminalTimestamp(item.expires_at_unix)}`
                : "No expiry";
            return (
              <div
                key={item.terminal_id}
                role="presentation"
                className="terminal-tab"
                data-active={active || undefined}
                data-locked={locked || undefined}
              >
                <button
                  type="button"
                  role="tab"
                  aria-selected={active}
                  className="terminal-tab-select"
                  disabled={locked || connection === "connecting"}
                  title={`${locked ? "Attached in another browser\n" : ""}${tabLabel}\nCreated ${terminalTimestamp(item.created_at_unix)}\n${timingTitle}`}
                  onClick={() => onActivate(item)}
                >
                  <span
                    className="terminal-tab-dot"
                    data-state={
                      active
                        ? connection
                        : locked
                          ? "attached"
                          : item.agent_attached
                            ? "detached"
                            : "disconnected"
                    }
                    aria-hidden
                  />
                  <span className="terminal-tab-label">{tabLabel}</span>
                  <time
                    className={
                      expiry?.warning ? "text-amber-400" : "text-[#7f8d9a]"
                    }
                    dateTime={new Date(
                      (item.expires_at_unix ?? item.created_at_unix) * 1000,
                    ).toISOString()}
                  >
                    {expiry?.label ?? terminalCreatedTime(item.created_at_unix)}
                  </time>
                </button>
                <button
                  type="button"
                  className="terminal-tab-close"
                  disabled={locked}
                  aria-label={`Close ${agentLabel} terminal session`}
                  title={
                    locked ? "Attached in another browser" : "Close session"
                  }
                  onClick={() => onClose(item)}
                >
                  <X className="size-3.5" aria-hidden />
                </button>
              </div>
            );
          })
        )}
      </div>
      <Tooltip>
        <TooltipTrigger>
          <Button
            type="button"
            size="icon"
            variant="ghost"
            className="terminal-new-tab"
            disabled={!canRequestStart}
            aria-label="New terminal session"
            onClick={onStart}
          >
            <Plus className="size-4" aria-hidden />
          </Button>
        </TooltipTrigger>
        <TooltipContent>
          {agentAtSessionLimit
            ? `${selectedAgentSessionLimit}-session limit reached`
            : "New session"}
        </TooltipContent>
      </Tooltip>
    </div>
  );
 }
@@ -0,0 +1,113 @@
 import type { Terminal as XTerm } from "@xterm/xterm";
 import type { TerminalSession } from "@/api";
 export type TerminalConnectionState =
  | "idle"
  | "connecting"
  | "ready"
  | "disconnected"
  | "exited";
 export type TerminalModifiers = {
  ctrl: boolean;
  meta: boolean;
 };
 export const NO_TERMINAL_MODIFIERS: TerminalModifiers = {
  ctrl: false,
  meta: false,
 };
 export function mergeTerminalSession(
  sessions: TerminalSession[],
  next: TerminalSession,
 ): TerminalSession[] {
  const existingIndex = sessions.findIndex(
    (item) => item.terminal_id === next.terminal_id,
  );
  if (existingIndex >= 0) {
    // Attaching updates session state, not identity or tab position. Removing
    // and re-inserting here made same-second sessions swap places on click.
    return sessions.map((item, index) =>
      index === existingIndex ? next : item,
    );
  }
  return orderTerminalSessions([...sessions, next]);
 }
 function compareTerminalSessions(
  left: TerminalSession,
  right: TerminalSession,
 ): number {
  return (
    left.created_at_unix - right.created_at_unix ||
    left.terminal_id.localeCompare(right.terminal_id)
  );
 }
 export function orderTerminalSessions(
  sessions: TerminalSession[],
 ): TerminalSession[] {
  return [...sessions].sort(compareTerminalSessions);
 }
 export function reconcileTerminalSessions(
  current: TerminalSession[],
  listed: TerminalSession[],
 ): TerminalSession[] {
  const listedById = new Map(listed.map((item) => [item.terminal_id, item]));
  const retained = current.flatMap((item) => {
    const updated = listedById.get(item.terminal_id);
    if (!updated) return [];
    listedById.delete(item.terminal_id);
    return [updated];
  });
  return [...retained, ...orderTerminalSessions([...listedById.values()])];
 }
 export function restoreCandidates(
  sessions: TerminalSession[],
  rememberedId: string | null,
  selectedAgentId: string,
 ): TerminalSession[] {
  const remembered = sessions.find((item) => item.terminal_id === rememberedId);
  const available = sessions.filter(
    (item) => !item.operator_attached && item !== remembered,
  );
  available.sort((left, right) => {
    const leftPreferred = left.agent_id === selectedAgentId ? 1 : 0;
    const rightPreferred = right.agent_id === selectedAgentId ? 1 : 0;
    return (
      rightPreferred - leftPreferred ||
      right.created_at_unix - left.created_at_unix
    );
  });
  return remembered ? [remembered, ...available] : available;
 }
 export function applyTerminalModifiers(
  data: string,
  modifiers: TerminalModifiers,
 ): string {
  let modified = data;
  if (modifiers.ctrl && modified.length === 1) {
    const code = modified.toUpperCase().charCodeAt(0);
    if (code >= 64 && code <= 95) {
      modified = String.fromCharCode(code & 0x1f);
    }
  }
  return modifiers.meta ? `\x1b${modified}` : modified;
 }
 export function visibleTerminalText(terminal: XTerm): string {
  const buffer = terminal.buffer.active;
  const firstLine = buffer.viewportY;
  const lastLine = Math.min(buffer.length, firstLine + terminal.rows);
  const lines: string[] = [];
  for (let index = firstLine; index < lastLine; index += 1) {
    lines.push(buffer.getLine(index)?.translateToString(true) ?? "");
  }
  while (lines.at(-1) === "") lines.pop();
  return lines.join("\n");
 }
@@ -135,7 +135,7 @@
    @apply border-border outline-ring/50;
  }
  body {
-    @apply bg-background text-foreground;
+    @apply bg-background text-foreground transition-colors duration-100 ease-in-out;
    margin: 0;
    -webkit-font-smoothing: antialiased;
    -moz-osx-font-smoothing: grayscale;
@@ -189,6 +189,13 @@
  background-size: 100% 100%;
  overflow-y: auto;
  max-width: 100%;
  transition: background 100ms ease-in-out;
 }
 /* xterm focuses an input near the active row. Keep that focus operation from
   scrolling the page shell and moving the terminal toolbar off-screen. */
 .app-main:has(.terminal-page) {
  overflow: hidden;
 }
 /* ── Sidebar internals ────────────────────────────────────────────────── */
@@ -315,6 +322,407 @@
  padding: 0.5rem;
 }
 /* ── Remote terminal ─────────────────────────────────────────────────── */
 .terminal-page {
  display: flex;
  height: calc(var(--terminal-visual-viewport-height, 100dvh) - 2.5rem);
  min-height: 0;
  flex-direction: column;
  gap: 1rem;
  overflow: hidden;
 }
 .terminal-toolbar {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 1rem;
  flex-wrap: wrap;
 }
 .terminal-heading {
  display: flex;
  align-items: center;
  gap: 0.65rem;
 }
 .terminal-heading h1 {
  margin: 0;
  font-size: 1.0625rem;
  font-weight: 650;
 }
 .terminal-controls {
  display: flex;
  align-items: center;
  justify-content: flex-end;
  gap: 0.5rem;
  flex-wrap: wrap;
 }
 .terminal-status {
  gap: 0.4rem;
  height: 1.4rem;
  padding-inline: 0.45rem;
  border-color: rgb(255 255 255 / 14%);
  background: rgb(255 255 255 / 5%);
  color: #cbd5e1;
  font-size: 0.6875rem;
  text-transform: capitalize;
 }
 .terminal-status > span {
  width: 0.45rem;
  height: 0.45rem;
  border-radius: 999px;
  background: var(--presence-unknown);
 }
 .terminal-status[data-state="ready"] > span {
  background: var(--presence-online);
 }
 .terminal-status[data-state="connecting"] > span {
  background: var(--presence-likely);
 }
 .terminal-status[data-state="disconnected"] > span,
 .terminal-status[data-state="exited"] > span {
  background: var(--presence-offline);
 }
 .terminal-notice {
  margin: 0;
  color: var(--muted-foreground);
  font-size: 0.8125rem;
 }
 .terminal-frame {
  display: flex;
  flex: 1;
  min-height: 0;
  flex-direction: column;
  overflow: hidden;
  border: 1px solid var(--border);
  border-radius: var(--radius);
  background: #0b1117;
 }
 .terminal-framebar {
  display: flex;
  min-height: 2.5rem;
  flex-shrink: 0;
  align-items: center;
  justify-content: space-between;
  gap: 0.75rem;
  padding: 0.35rem 0.45rem 0.35rem 0.75rem;
  border-bottom: 1px solid color-mix(in oklab, white 9%, transparent);
  background: #101820;
  color: #cbd5e1;
 }
 .terminal-session-label,
 .terminal-frame-actions {
  display: flex;
  min-width: 0;
  align-items: center;
  gap: 0.5rem;
 }
 .terminal-tabs {
  display: flex;
  min-width: 0;
  flex: 1;
  align-items: center;
  gap: 0.25rem;
 }
 .terminal-tab-list {
  display: flex;
  min-width: 0;
  flex: 1;
  align-items: center;
  gap: 0.25rem;
  overflow-x: auto;
  scrollbar-width: none;
 }
 .terminal-tab-list::-webkit-scrollbar {
  display: none;
 }
 .terminal-tab {
  display: flex;
  min-width: 0;
  max-width: min(20rem, 48vw);
  height: 1.85rem;
  flex: 0 0 auto;
  align-items: center;
  border: 1px solid transparent;
  border-radius: calc(var(--radius) - 2px);
  background: transparent;
  font-size: 0.75rem;
  color: #aab7c4;
 }
 .terminal-tab-select {
  display: flex;
  min-width: 0;
  height: 100%;
  flex: 1;
  align-items: center;
  gap: 0.45rem;
  padding: 0 0.35rem 0 0.6rem;
  border: 0;
  background: transparent;
  color: inherit;
 }
 .terminal-tab-label {
  min-width: 0;
  overflow: hidden;
  text-overflow: ellipsis;
  white-space: nowrap;
 }
 .terminal-tab time {
  flex: 0 0 auto;
  font-size: 0.6875rem;
 }
 .terminal-tab[data-active] {
  max-width: min(30rem, 60vw);
  border-color: rgb(255 255 255 / 10%);
  background: rgb(255 255 255 / 7%);
  color: #f1f5f9;
 }
 .terminal-tab[data-locked] {
  opacity: 0.58;
 }
 .terminal-tab-close {
  display: grid;
  width: 1.6rem;
  height: 100%;
  flex: 0 0 auto;
  place-items: center;
  border: 0;
  border-radius: calc(var(--radius) - 3px);
  background: transparent;
  color: #7f8d9a;
  opacity: 0.72;
 }
 .terminal-tab-close:focus-visible,
 .terminal-tab-close:hover,
 .terminal-tab[data-active] .terminal-tab-close {
  opacity: 1;
 }
 .terminal-tab-close:disabled {
  visibility: hidden;
 }
 .terminal-new-tab {
  width: 1.85rem;
  height: 1.85rem;
  flex: 0 0 auto;
 }
 .terminal-tab-dot {
  width: 0.45rem;
  height: 0.45rem;
  flex: 0 0 auto;
  border-radius: 999px;
  background: var(--presence-unknown);
 }
 .terminal-tab-dot[data-state="ready"],
 .terminal-tab-dot[data-state="attached"] {
  background: var(--presence-online);
 }
 .terminal-tab-dot[data-state="connecting"],
 .terminal-tab-dot[data-state="detached"] {
  background: var(--presence-likely);
 }
 .terminal-tab-dot[data-state="disconnected"],
 .terminal-tab-dot[data-state="exited"] {
  background: var(--presence-offline);
 }
 .terminal-frame-actions {
  flex: 0 0 auto;
 }
 .terminal-session-label > span:not(.terminal-status) {
  overflow: hidden;
  color: #dbe4ee;
  font-size: 0.75rem;
  font-weight: 550;
  text-overflow: ellipsis;
  white-space: nowrap;
 }
 .terminal-framebar button {
  color: #aab7c4;
 }
 .terminal-framebar button:hover {
  color: #f1f5f9;
  background: rgb(255 255 255 / 7%);
 }
 .terminal-surface {
  order: 2;
  flex: 1;
  min-height: 0;
  overflow: hidden;
  background: #0b1117;
  padding: 0;
 }
 .terminal-accessories-toggle[data-active] {
  color: #6ee7a8;
  background: rgb(110 231 168 / 10%);
 }
 .terminal-accessories {
  display: flex;
  order: 3;
  min-width: 0;
  min-height: 2.75rem;
  flex: 0 0 auto;
  align-items: center;
  gap: 0.35rem;
  padding: 0.35rem 0.45rem max(0.35rem, env(safe-area-inset-bottom));
  overflow-x: auto;
  overscroll-behavior-x: contain;
  border-top: 1px solid rgb(255 255 255 / 9%);
  background: #101820;
  color: #cbd5e1;
  scrollbar-width: thin;
  touch-action: pan-x;
 }
 .terminal-accessory-group {
  display: flex;
  flex: 0 0 auto;
  align-items: center;
  gap: 0.25rem;
 }
 .terminal-accessory-group + .terminal-accessory-group {
  padding-left: 0.35rem;
  border-left: 1px solid rgb(255 255 255 / 10%);
 }
 .terminal-accessories .terminal-key {
  width: auto;
  min-width: 2.4rem;
  height: 2rem;
  padding-inline: 0.55rem;
  border: 1px solid rgb(255 255 255 / 9%);
  border-radius: calc(var(--radius) - 3px);
  background: rgb(255 255 255 / 4%);
  color: #cbd5e1;
  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
  font-size: 0.75rem;
 }
 .terminal-accessories .terminal-key:hover {
  background: rgb(255 255 255 / 9%);
  color: #f1f5f9;
 }
 .terminal-accessories .terminal-key[data-active] {
  border-color: rgb(110 231 168 / 48%);
  background: rgb(110 231 168 / 14%);
  color: #9af0bf;
 }
 .terminal-accessories .terminal-key--icon {
  width: 2rem;
  min-width: 2rem;
  padding: 0;
 }
 .terminal-accessories .terminal-key--control {
  min-width: 2.25rem;
 }
 .terminal-accessories .terminal-key--wide {
  min-width: 3.15rem;
 }
 .terminal-font-controls output {
  min-width: 1.5rem;
  color: #91a0ae;
  font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
  font-size: 0.6875rem;
  text-align: center;
 }
 .terminal-surface .xterm {
  height: 100%;
  box-sizing: border-box;
  background: #0b1117;
  padding: 0.75rem;
 }
 .terminal-surface .xterm-viewport {
  /* xterm defaults this element to pure black. It remains visible around the
     fitted canvas, so keep it on the same surface as the terminal theme. */
  background-color: #0b1117;
  overscroll-behavior: contain;
  scrollbar-width: none;
 }
 .terminal-surface .xterm-scrollable-element > .scrollbar,
 .terminal-surface .xterm-scrollable-element > .scrollbar > .slider {
  /* Without this, mobile browsers claim a thumb drag as page panning before
     xterm's pointer-capture scrollbar can process it. */
  touch-action: none;
 }
@media (max-width: 640px) {
  .terminal-page {
    height: calc(var(--terminal-visual-viewport-height, 100dvh) - 2.5rem);
  }
  .terminal-controls {
    width: 100%;
    justify-content: flex-start;
  }
  .terminal-surface {
    min-height: 0;
  }
  .terminal-surface .xterm {
    padding: 0.5rem;
  }
 }
@media (pointer: coarse) {
  .terminal-accessories {
    min-height: 3.25rem;
  }
  .terminal-accessories .terminal-key {
    min-width: 2.75rem;
    height: 2.75rem;
  }
  .terminal-accessories .terminal-key--icon {
    width: 2.75rem;
    min-width: 2.75rem;
  }
 }
 /* ── Presence badges ──────────────────────────────────────────────────── */
 .presence-dot {
@@ -0,0 +1,8 @@
@font-face {
  font-family: "Wakey JetBrainsMono Nerd Font Mono";
  src: url("../assets/fonts/jetbrains-mono-nerd/JetBrainsMonoNerdFontMono-Regular.woff2")
    format("woff2");
  font-style: normal;
  font-weight: 400;
  font-display: block;
 }
@@ -0,0 +1,31 @@
 import "./terminalFonts.css";
 const TERMINAL_WEB_FONT = "Wakey JetBrainsMono Nerd Font Mono";
 const TERMINAL_FALLBACK_FONTS =
  '"SFMono-Regular", Consolas, "Liberation Mono", monospace';
 let terminalFontsPromise: Promise<string> | undefined;
 /**
 * Resolves the terminal font stack only after browser glyph metrics are ready.
 * xterm caches those metrics when it opens, so a late webfont load permanently
 * misaligns cells for that terminal instance.
 */
 export function loadTerminalFontFamily(): Promise<string> {
  terminalFontsPromise ??= document.fonts
    .load(`400 14px "${TERMINAL_WEB_FONT}"`, "\uE0B0")
    .then((faces) => {
      if (faces.length === 0) {
        throw new Error("terminal webfont was not registered");
      }
      return `"${TERMINAL_WEB_FONT}", ${TERMINAL_FALLBACK_FONTS}`;
    })
    .catch((error: unknown) => {
      console.warn(
        "Could not load terminal webfont; using system monospace",
        error,
      );
      return TERMINAL_FALLBACK_FONTS;
    });
  return terminalFontsPromise;
 }
@@ -1,7 +1,7 @@
 {
  "compilerOptions": {
    "target": "ES2020",
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "ignoreDeprecations": "5.0",
    "moduleResolution": "Bundler",
@@ -1,6 +1,6 @@
 [package]
 name = "wakey-agent"
-version = "0.3.0"
+version = "0.3.5"
 edition = "2024"
 publish = ["gitea"]
@@ -23,6 +23,7 @@ serde_json = "1"
 tokio = { version = "1", features = [
    "fs",
    "macros",
    "io-util",
    "rt-multi-thread",
    "time",
    "signal",
@@ -38,5 +39,6 @@ tracing-subscriber = { version = "0.3", features = [
 ] }
 time = { version = "0.3", features = ["formatting", "local-offset"] }
 url = "2"
 vt100 = { package = "wakey-vt100", path = "../vendor/vt100", registry = "gitea", version = "=0.16.2-wakey.2" }
 wakey = { path = "..", registry = "gitea", version = "0" }
 wakey-core = { path = "../wakey-core", registry = "gitea", version = "0" }
@@ -98,6 +98,10 @@ pub struct InitConfigArgs {
    #[arg(long)]
    pub agent_token: Option<String>,
    /// Days to keep local hook observation rows since last seen. Zero disables pruning.
    #[arg(long)]
    pub observation_retention_days: Option<u64>,
    /// Replace an existing config file.
    #[arg(long)]
    pub force: bool,
@@ -2,6 +2,12 @@ use anyhow::{Context, Result};
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::path::{Path, PathBuf};
 use std::sync::LazyLock;
 use crate::protocol::{
    DEFAULT_TERMINAL_MAX_SESSIONS, DEFAULT_TERMINAL_SESSION_TTL_SECONDS,
    checked_terminal_session_ttl,
 };
 pub const DEFAULT_CONFIG_PATH: &str = "/etc/wakey-agent/config.toml";
 pub const DEFAULT_PID_FILE: &str = "/var/run/wakey-agent.pid";
@@ -11,6 +17,7 @@ const WAKEY_OBSERVATION_STORE_ENV: &str = "WAKEY_OBSERVATION_STORE";
 const DEFAULT_DHCP_LEASES_PATH: &str = "/tmp/dhcp.leases";
 const DEFAULT_MAC_NAME_CACHE_PATH: &str = "/tmp/wakey_mac_names.json";
 const DEFAULT_OBSERVATION_STORE_PATH: &str = "/tmp/wakey_observations.json";
 pub const DEFAULT_OBSERVATION_RETENTION_DAYS: u64 = 7;
 #[derive(Clone, Serialize, Deserialize, PartialEq, Eq)]
 pub struct AgentConfig {
@@ -23,6 +30,8 @@ pub struct AgentConfig {
    pub reconnect_max_ms: u64,
    #[serde(default = "default_observation_sync_interval_seconds")]
    pub observation_sync_interval_seconds: u64,
    #[serde(default = "default_observation_retention_days")]
    pub observation_retention_days: u64,
    #[serde(default = "default_pid_file")]
    pub pid_file: PathBuf,
    #[serde(default = "default_dhcp_leases_path")]
@@ -31,8 +40,56 @@ pub struct AgentConfig {
    pub mac_name_cache_path: PathBuf,
    #[serde(default = "default_observation_store_path")]
    pub observation_store_path: PathBuf,
    #[serde(default)]
    pub terminal: TerminalConfig,
 }
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 #[serde(deny_unknown_fields)]
 pub struct TerminalConfig {
    #[serde(default)]
    pub enabled: bool,
    #[serde(default = "default_terminal_shell")]
    pub shell: PathBuf,
    #[serde(default)]
    pub args: Vec<String>,
    #[serde(default)]
    pub current_dir: Option<PathBuf>,
    #[serde(default = "default_terminal_max_sessions")]
    pub max_sessions: usize,
    /// Maximum lifetime of a PTY process. Zero disables automatic expiry.
    #[serde(default = "default_terminal_session_ttl_seconds")]
    pub session_ttl_seconds: u64,
 }
 impl Default for TerminalConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            shell: default_terminal_shell(),
            args: Vec::new(),
            current_dir: None,
            max_sessions: default_terminal_max_sessions(),
            session_ttl_seconds: default_terminal_session_ttl_seconds(),
        }
    }
 }
 pub static DEFAULT_CONFIG: LazyLock<AgentConfig> = LazyLock::new(|| AgentConfig {
    server_url: "https://wakey.ldlda.com".to_string(),
    agent_id: "REPLACE_ME_AGENT_ID".to_string(),
    agent_token: "REPLACE_ME_AGENT_TOKEN".to_string(),
    reconnect_base_ms: default_reconnect_base_ms(),
    reconnect_max_ms: default_reconnect_max_ms(),
    observation_sync_interval_seconds: default_observation_sync_interval_seconds(),
    observation_retention_days: default_observation_retention_days(),
    pid_file: default_pid_file(),
    dhcp_leases_path: default_dhcp_leases_path(),
    mac_name_cache_path: default_mac_name_cache_path(),
    observation_store_path: default_observation_store_path(),
    terminal: TerminalConfig::default(),
 });
 impl fmt::Debug for AgentConfig {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("AgentConfig")
@@ -45,10 +102,15 @@ impl fmt::Debug for AgentConfig {
                "observation_sync_interval_seconds",
                &self.observation_sync_interval_seconds,
            )
            .field(
                "observation_retention_days",
                &self.observation_retention_days,
            )
            .field("pid_file", &self.pid_file)
            .field("dhcp_leases_path", &self.dhcp_leases_path)
            .field("mac_name_cache_path", &self.mac_name_cache_path)
            .field("observation_store_path", &self.observation_store_path)
            .field("terminal", &self.terminal)
            .finish()
    }
 }
@@ -65,6 +127,10 @@ const fn default_observation_sync_interval_seconds() -> u64 {
    60
 }
 const fn default_observation_retention_days() -> u64 {
    DEFAULT_OBSERVATION_RETENTION_DAYS
 }
 fn default_pid_file() -> PathBuf {
    DEFAULT_PID_FILE.into()
 }
@@ -81,6 +147,24 @@ fn default_observation_store_path() -> PathBuf {
    DEFAULT_OBSERVATION_STORE_PATH.into()
 }
 fn default_terminal_shell() -> PathBuf {
    "/bin/sh".into()
 }
 const fn default_terminal_max_sessions() -> usize {
    DEFAULT_TERMINAL_MAX_SESSIONS
 }
 const fn default_terminal_session_ttl_seconds() -> u64 {
    DEFAULT_TERMINAL_SESSION_TTL_SECONDS
 }
 impl TerminalConfig {
    pub(crate) fn session_ttl(&self) -> Result<Option<std::time::Duration>> {
        checked_terminal_session_ttl(self.session_ttl_seconds).map_err(anyhow::Error::msg)
    }
 }
 impl AgentConfig {
    pub fn local_path_envs(&self) -> Vec<(&'static str, &Path)> {
        vec![
@@ -103,8 +187,10 @@ pub fn apply_local_path_env_to_command(cmd: &mut std::process::Command, config:
 pub fn load_config(path: &Path) -> Result<AgentConfig> {
    let content = std::fs::read_to_string(path)
        .with_context(|| format!("failed to read agent config {}", path.display()))?;
-    toml::from_str(&content)
+    let config: AgentConfig = toml::from_str(&content)
-        .with_context(|| format!("failed to parse agent config {}", path.display()))
+        .with_context(|| format!("failed to parse agent config {}", path.display()))?;
    config.terminal.session_ttl()?;
    Ok(config)
 }
 pub fn save_config(path: &Path, config: &AgentConfig) -> Result<()> {
@@ -183,10 +269,19 @@ mod tests {
            reconnect_base_ms: 123,
            reconnect_max_ms: 456,
            observation_sync_interval_seconds: 7,
            observation_retention_days: 3,
            pid_file: "/tmp/test-wakey-agent.pid".into(),
            dhcp_leases_path: "/tmp/test-dhcp.leases".into(),
            mac_name_cache_path: "/tmp/test-names.json".into(),
            observation_store_path: "/tmp/test-observations.json".into(),
            terminal: TerminalConfig {
                enabled: true,
                shell: "/bin/sh".into(),
                args: vec!["-l".into()],
                current_dir: Some("/tmp".into()),
                max_sessions: 2,
                session_ttl_seconds: 600,
            },
        };
        save_config(&path, &config).expect("save");
@@ -202,4 +297,82 @@ mod tests {
        let _ = std::fs::remove_file(&path);
        let _ = std::fs::remove_dir_all(&dir);
    }
    #[test]
    fn config_without_retention_uses_current_default() {
        let config: AgentConfig = toml::from_str(
            r#"
 server_url = "https://example.com"
 agent_id = "agent-1"
 agent_token = "secret"
 "#,
        )
        .expect("config should parse");
        assert_eq!(
            config.observation_retention_days,
            DEFAULT_OBSERVATION_RETENTION_DAYS
        );
        assert_eq!(config.terminal, TerminalConfig::default());
    }
    #[test]
    fn existing_terminal_config_defaults_optional_command_fields() {
        let config: AgentConfig = toml::from_str(
            r#"
 server_url = "https://example.com"
 agent_id = "agent-1"
 agent_token = "secret"
 [terminal]
 enabled = true
 shell = "/bin/sh"
 max_sessions = 2
 "#,
        )
        .expect("existing terminal config should parse");
        assert!(config.terminal.args.is_empty());
        assert!(config.terminal.current_dir.is_none());
        assert_eq!(
            config.terminal.session_ttl_seconds,
            DEFAULT_TERMINAL_SESSION_TTL_SECONDS
        );
    }
    #[test]
    fn terminal_config_rejects_misspelled_fields() {
        let error = toml::from_str::<AgentConfig>(
            r#"
 server_url = "https://example.com"
 agent_id = "agent-1"
 agent_token = "secret"
 [terminal]
 enabled = true
 max_session = 67
 "#,
        )
        .expect_err("unknown terminal fields must not silently use defaults");
        assert!(error.to_string().contains("max_session"));
    }
    #[test]
    fn terminal_ttl_zero_is_unlimited_and_positive_is_exact() {
        let mut terminal = TerminalConfig {
            session_ttl_seconds: 0,
            ..TerminalConfig::default()
        };
        assert_eq!(terminal.session_ttl().expect("unlimited TTL"), None);
        terminal.session_ttl_seconds = 67;
        assert_eq!(
            terminal.session_ttl().expect("finite TTL"),
            Some(std::time::Duration::from_secs(67))
        );
        terminal.session_ttl_seconds = u64::MAX;
        assert!(terminal.session_ttl().is_err());
    }
 }
@@ -64,6 +64,15 @@ async fn dispatch_devs(req: DevsRequest) -> Result<CommandResult> {
 }
 async fn dispatch_inventory(req: InventoryRequest, config: &AgentConfig) -> Result<CommandResult> {
    Ok(CommandResult::Inventory(
        inventory_for_config(req, config).await?,
    ))
 }
 pub async fn inventory_for_config(
    req: InventoryRequest,
    config: &AgentConfig,
 ) -> Result<wakey_core::DeviceInventory> {
    let query = req.into_inventory_query();
    let neighbors = wakey::wakey_linux::devices::query_neighbors(&query).await?;
    let leases = wakey::wakey_linux::dhcp::read_dhcp_leases_with_names_from_paths(
@@ -72,6 +81,20 @@ async fn dispatch_inventory(req: InventoryRequest, config: &AgentConfig) -> Resu
        &config.mac_name_cache_path,
    )
    .await?;
    match wakey::wakey_linux::observations::prune_stale_observations_from_path(
        &config.observation_store_path,
        config.observation_retention_days,
    )
    .await
    {
        Ok(removed) if removed > 0 => {
            debug!(removed, "pruned stale local hook observations");
        }
        Ok(_) => {}
        Err(err) => {
            warn!(error = %err, "failed pruning stale local hook observations");
        }
    }
    let observations = match wakey::wakey_linux::observations::list_local_observations_from_path(
        &config.observation_store_path,
    )
@@ -104,7 +127,7 @@ async fn dispatch_inventory(req: InventoryRequest, config: &AgentConfig) -> Resu
        rows = inventory.devices.len(),
        "dispatched inventory command"
    );
-    Ok(CommandResult::Inventory(inventory))
+    Ok(inventory)
 }
 async fn dispatch_wake(req: WakeRequest) -> Result<CommandResult> {
@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
 use tracing::{info, warn};
-use crate::config::{AgentConfig, save_config_with_backup};
+use crate::config::{AgentConfig, DEFAULT_CONFIG, save_config_with_backup};
 pub struct EnrollOutcome {
    pub config: AgentConfig,
@@ -55,32 +55,12 @@ pub async fn enroll(
        .await
        .context("failed to decode enrollment response")?;
-    let config = AgentConfig {
+    let mut config = base_config
-        server_url: payload.server_url.unwrap_or(server_url),
+        .cloned()
-        agent_id: payload.agent_id,
+        .unwrap_or_else(|| (*DEFAULT_CONFIG).clone());
-        agent_token: payload.agent_token,
+    config.server_url = payload.server_url.unwrap_or(server_url);
-        reconnect_base_ms: base_config
+    config.agent_id = payload.agent_id;
-            .map(|config| config.reconnect_base_ms)
+    config.agent_token = payload.agent_token;
            .unwrap_or(1_000),
        reconnect_max_ms: base_config
            .map(|config| config.reconnect_max_ms)
            .unwrap_or(30_000),
        observation_sync_interval_seconds: base_config
            .map(|config| config.observation_sync_interval_seconds)
            .unwrap_or(60),
        pid_file: base_config
            .map(|config| config.pid_file.clone())
            .unwrap_or_else(|| crate::config::DEFAULT_PID_FILE.into()),
        dhcp_leases_path: base_config
            .map(|config| config.dhcp_leases_path.clone())
            .unwrap_or_else(|| "/tmp/dhcp.leases".into()),
        mac_name_cache_path: base_config
            .map(|config| config.mac_name_cache_path.clone())
            .unwrap_or_else(|| "/tmp/wakey_mac_names.json".into()),
        observation_store_path: base_config
            .map(|config| config.observation_store_path.clone())
            .unwrap_or_else(|| "/tmp/wakey_observations.json".into()),
    };
    let backup_path = save_config_with_backup(config_path, &config)?;
    info!(agent_id = %config.agent_id, config_path = %config_path.display(), "agent enrollment succeeded and config was written");
    Ok(EnrollOutcome {
@@ -166,10 +146,19 @@ mod tests {
            reconnect_base_ms: 2_000,
            reconnect_max_ms: 60_000,
            observation_sync_interval_seconds: 30,
            observation_retention_days: 11,
            pid_file: "/tmp/custom-wakey-agent.pid".into(),
            dhcp_leases_path: "/tmp/custom-dhcp.leases".into(),
            mac_name_cache_path: "/tmp/custom-names.json".into(),
            observation_store_path: "/tmp/custom-observations.json".into(),
            terminal: crate::config::TerminalConfig {
                enabled: true,
                shell: "/bin/ash".into(),
                args: vec!["-l".into()],
                current_dir: Some("/root".into()),
                max_sessions: 2,
                session_ttl_seconds: 600,
            },
        };
        let outcome = enroll(&server_url, "enroll-abc", &path, Some(&base_config))
@@ -180,8 +169,10 @@ mod tests {
        assert_eq!(config.agent_id, "agent-123");
        assert_eq!(config.agent_token, "token-xyz");
        assert_eq!(config.server_url, "https://control.example.com");
        assert_eq!(config.observation_retention_days, 11);
        assert_eq!(config.pid_file, base_config.pid_file);
        assert_eq!(config.dhcp_leases_path, base_config.dhcp_leases_path);
        assert_eq!(config.terminal, base_config.terminal);
        assert!(outcome.backup_path.is_none());
        let persisted = crate::config::load_config(&path).expect("load persisted config");
@@ -2,14 +2,15 @@ mod cli;
 mod config;
 mod dispatch;
 mod enroll;
 mod protocol;
 mod serve;
 mod session;
 mod terminal;
 mod tracing;
 use anyhow::Result;
 use clap::Parser;
 use cli::{Cli, Command, InitConfigArgs, ObserveCommand};
 use wakey_agent::protocol;
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -248,18 +249,7 @@ fn init_config(args: InitConfigArgs) -> Result<()> {
    let mut cfg = if let Some(from_config) = &args.from_config {
        config::load_config(from_config)?
    } else {
-        config::AgentConfig {
+        (*config::DEFAULT_CONFIG).clone()
            server_url: "https://wakey.ldlda.com".to_string(),
            agent_id: "REPLACE_ME_AGENT_ID".to_string(),
            agent_token: "REPLACE_ME_AGENT_TOKEN".to_string(),
            reconnect_base_ms: 1_000,
            reconnect_max_ms: 30_000,
            observation_sync_interval_seconds: 60,
            pid_file: config::DEFAULT_PID_FILE.into(),
            dhcp_leases_path: "/tmp/dhcp.leases".into(),
            mac_name_cache_path: "/tmp/wakey_mac_names.json".into(),
            observation_store_path: "/tmp/wakey_observations.json".into(),
        }
    };
    if let Some(server_url) = args.server_url {
@@ -271,6 +261,9 @@ fn init_config(args: InitConfigArgs) -> Result<()> {
    if let Some(agent_token) = args.agent_token {
        cfg.agent_token = agent_token;
    }
    if let Some(days) = args.observation_retention_days {
        cfg.observation_retention_days = days;
    }
    if let Some(path) = &args.config {
        config::save_config(path, &cfg)?;
@@ -2,6 +2,7 @@ use macaddr::MacAddr;
 use serde::{Deserialize, Serialize};
 use std::fmt;
 use std::net::IpAddr;
 use std::time::{Duration, Instant};
 use wakey_core::parse::mac;
 use wakey_core::{
    Device, DeviceInventory, DhcpLeaseWithState, InterfaceSummary, InventoryQuery,
@@ -17,6 +18,138 @@ impl RequestId {
    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize)]
 #[serde(transparent)]
 pub struct TerminalId(String);
 impl TerminalId {
    pub fn new(value: impl Into<String>) -> Result<Self, String> {
        let value = value.into();
        if value.trim().is_empty() {
            return Err("terminal_id must not be empty".into());
        }
        Ok(Self(value))
    }
    pub fn as_str(&self) -> &str {
        &self.0
    }
 }
 impl fmt::Display for TerminalId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
 }
 impl TryFrom<String> for TerminalId {
    type Error = String;
    fn try_from(value: String) -> Result<Self, Self::Error> {
        Self::new(value)
    }
 }
 impl<'de> Deserialize<'de> for TerminalId {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let raw = String::deserialize(deserializer)?;
        Self::try_from(raw).map_err(serde::de::Error::custom)
    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum AgentCapability {
    Terminal,
 }
 pub const DEFAULT_TERMINAL_MAX_SESSIONS: usize = 2;
 pub const DEFAULT_TERMINAL_SESSION_TTL_SECONDS: u64 = 12 * 60 * 60;
 /// Validates a terminal TTL against the platform's monotonic timer range.
 /// Zero is the explicit unlimited policy.
 pub fn checked_terminal_session_ttl(
    session_ttl_seconds: u64,
 ) -> Result<Option<Duration>, &'static str> {
    if session_ttl_seconds == 0 {
        return Ok(None);
    }
    let ttl = Duration::from_secs(session_ttl_seconds);
    Instant::now()
        .checked_add(ttl)
        .ok_or("terminal session TTL is too large for the platform timer")?;
    Ok(Some(ttl))
 }
 const fn default_terminal_session_ttl_seconds() -> u64 {
    DEFAULT_TERMINAL_SESSION_TTL_SECONDS
 }
 /// Optional parameters attached to advertised agent capabilities.
 ///
 /// Keep this separate from `AgentCapability`: the capability list remains a
 /// compact, backward-compatible feature check, while this object can grow as
 /// individual capabilities gain configurable limits or modes.
 #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
 pub struct AgentCapabilityOptions {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub terminal: Option<TerminalCapabilityOptions>,
 }
 impl AgentCapabilityOptions {
    fn is_empty(&self) -> bool {
        self.terminal.is_none()
    }
 }
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct TerminalCapabilityOptions {
    pub max_sessions: usize,
    #[serde(default = "default_terminal_session_ttl_seconds")]
    pub session_ttl_seconds: u64,
 }
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct AgentTerminalSession {
    pub terminal_id: TerminalId,
    pub created_at_unix: u64,
    /// The policy captured when this PTY was created. Zero means unlimited.
    #[serde(default = "default_terminal_session_ttl_seconds")]
    pub session_ttl_seconds: u64,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum TerminalControl {
    Resize { rows: u16, cols: u16 },
    Snapshot,
    Ready,
    Exited { exit_code: Option<i32> },
    Error { code: String, message: String },
    Close,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum TerminalAgentHandshake {
    Auth {
        agent_id: String,
        relay_token: String,
    },
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "snake_case")]
 pub enum TerminalOperatorHandshake {
    Attach {
        attachment_token: String,
        operator_id: String,
    },
 }
 impl TryFrom<String> for RequestId {
    type Error = String;
@@ -153,6 +286,10 @@ pub enum CommandResult {
 pub enum ClientMessage {
    Hello {
        agent_id: String,
        #[serde(default, skip_serializing_if = "Vec::is_empty")]
        capabilities: Vec<AgentCapability>,
        #[serde(default, skip_serializing_if = "AgentCapabilityOptions::is_empty")]
        capability_options: AgentCapabilityOptions,
    },
    Auth {
        agent_id: String,
@@ -173,6 +310,13 @@ pub enum ClientMessage {
        request_id: RequestId,
        error: ErrorPayload,
    },
    TerminalRejected {
        terminal_id: TerminalId,
        error: ErrorPayload,
    },
    TerminalSessions {
        sessions: Vec<AgentTerminalSession>,
    },
 }
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -183,6 +327,20 @@ pub enum ServerMessage {
        command: AgentCommand,
    },
    SyncDeviceSnapshot,
    SyncTerminalSessions,
    OpenTerminal {
        terminal_id: TerminalId,
        relay_token: String,
        rows: u16,
        cols: u16,
    },
    CloseTerminal {
        terminal_id: TerminalId,
    },
    ResumeTerminal {
        terminal_id: TerminalId,
        relay_token: String,
    },
 }
 #[cfg(test)]
@@ -209,6 +367,16 @@ mod tests {
        assert!(err.contains("must not be empty"));
    }
    #[test]
    fn terminal_id_deserialization_enforces_validation() {
        let valid: TerminalId = serde_json::from_str(r#""term-1""#).expect("valid terminal id");
        assert_eq!(valid.as_str(), "term-1");
        let error = serde_json::from_str::<TerminalId>(r#""   ""#)
            .expect_err("empty terminal id must fail");
        assert!(error.to_string().contains("must not be empty"));
    }
    #[test]
    fn client_result_with_devs_serializes() {
        let msg = ClientMessage::Result {
@@ -232,4 +400,103 @@ mod tests {
        assert!(json.contains("\"type\":\"device_snapshot\""));
        assert!(json.contains("\"devices\""));
    }
    #[test]
    fn terminal_messages_serialize_with_explicit_frame_types() {
        let message = ServerMessage::OpenTerminal {
            terminal_id: TerminalId::new("term-1").expect("terminal id"),
            relay_token: "secret".into(),
            rows: 30,
            cols: 120,
        };
        let json = serde_json::to_string(&message).expect("serialize open terminal");
        assert!(json.contains("\"type\":\"open_terminal\""));
        assert!(json.contains("\"terminal_id\":\"term-1\""));
        let resize = TerminalControl::Resize {
            rows: 40,
            cols: 160,
        };
        let json = serde_json::to_string(&resize).expect("serialize resize");
        assert_eq!(json, r#"{"type":"resize","rows":40,"cols":160}"#);
        let snapshot =
            serde_json::to_string(&TerminalControl::Snapshot).expect("serialize snapshot");
        assert_eq!(snapshot, r#"{"type":"snapshot"}"#);
        let operator = TerminalOperatorHandshake::Attach {
            attachment_token: "attach-secret".into(),
            operator_id: "browser-tab".into(),
        };
        let json = serde_json::to_string(&operator).expect("serialize operator handshake");
        assert_eq!(
            json,
            r#"{"type":"attach","attachment_token":"attach-secret","operator_id":"browser-tab"}"#
        );
        let inventory = ClientMessage::TerminalSessions {
            sessions: vec![AgentTerminalSession {
                terminal_id: TerminalId::new("term-1").expect("terminal id"),
                created_at_unix: 42,
                session_ttl_seconds: 600,
            }],
        };
        let json = serde_json::to_string(&inventory).expect("serialize terminal inventory");
        assert!(json.contains("\"type\":\"terminal_sessions\""));
        assert!(json.contains("\"created_at_unix\":42"));
        let resume = ServerMessage::ResumeTerminal {
            terminal_id: TerminalId::new("term-1").expect("terminal id"),
            relay_token: "replacement".into(),
        };
        let json = serde_json::to_string(&resume).expect("serialize terminal resume");
        assert!(json.contains("\"type\":\"resume_terminal\""));
    }
    #[test]
    fn hello_serializes_typed_capability_options() {
        let message = ClientMessage::Hello {
            agent_id: "router".into(),
            capabilities: vec![AgentCapability::Terminal],
            capability_options: AgentCapabilityOptions {
                terminal: Some(TerminalCapabilityOptions {
                    max_sessions: 3,
                    session_ttl_seconds: 600,
                }),
            },
        };
        let value = serde_json::to_value(message).expect("serialize hello");
        assert_eq!(value["capability_options"]["terminal"]["max_sessions"], 3);
        assert_eq!(
            value["capability_options"]["terminal"]["session_ttl_seconds"],
            600
        );
    }
    #[test]
    fn terminal_ttl_defaults_for_old_messages_and_preserves_explicit_zero() {
        let old_options: TerminalCapabilityOptions =
            serde_json::from_value(serde_json::json!({ "max_sessions": 2 }))
                .expect("deserialize old capability options");
        assert_eq!(
            old_options.session_ttl_seconds,
            DEFAULT_TERMINAL_SESSION_TTL_SECONDS
        );
        let old_session: AgentTerminalSession = serde_json::from_value(serde_json::json!({
            "terminal_id": "term-old",
            "created_at_unix": 42
        }))
        .expect("deserialize old terminal inventory");
        assert_eq!(
            old_session.session_ttl_seconds,
            DEFAULT_TERMINAL_SESSION_TTL_SECONDS
        );
        let unlimited: TerminalCapabilityOptions = serde_json::from_value(serde_json::json!({
            "max_sessions": 2,
            "session_ttl_seconds": 0
        }))
        .expect("deserialize unlimited capability options");
        assert_eq!(unlimited.session_ttl_seconds, 0);
    }
 }
@@ -7,13 +7,20 @@ use tokio_tungstenite::{connect_async, tungstenite::Message};
 use tracing::{debug, error, info, info_span, warn};
 use crate::config::AgentConfig;
-use crate::dispatch::dispatch_command;
+use crate::dispatch::{dispatch_command, inventory_for_config};
-use crate::protocol::{AgentCommand, ClientMessage, ErrorPayload, ServerMessage};
+use crate::protocol::{
    AgentCapability, AgentCapabilityOptions, AgentCommand, ClientMessage, ErrorPayload,
    ServerMessage, TerminalCapabilityOptions,
 };
 use crate::terminal::TerminalManager;
 pub async fn run(config: AgentConfig) -> Result<()> {
    // Terminal workers belong to the agent process, not a single control socket.
    // Keeping this manager outside the reconnect loop lets PTYs survive CC loss.
    let (terminal_manager, mut terminal_events) = TerminalManager::new(&config);
    let mut backoff = config.reconnect_base_ms.max(100);
    loop {
-        match run_once(&config).await {
+        match run_once(&config, &terminal_manager, &mut terminal_events).await {
            Ok(()) => {
                backoff = config.reconnect_base_ms.max(100);
            }
@@ -26,7 +33,13 @@ pub async fn run(config: AgentConfig) -> Result<()> {
    }
 }
-async fn run_once(config: &AgentConfig) -> Result<()> {
+async fn run_once(
    config: &AgentConfig,
    terminal_manager: &TerminalManager,
    terminal_events: &mut tokio::sync::mpsc::UnboundedReceiver<
        crate::terminal::TerminalManagerEvent,
    >,
 ) -> Result<()> {
    let session_id = format!(
        "{}-{}",
        std::process::id(),
@@ -71,6 +84,16 @@ async fn run_once(config: &AgentConfig) -> Result<()> {
        &mut sink,
        &ClientMessage::Hello {
            agent_id: config.agent_id.clone(),
            capabilities: agent_capabilities(config),
            capability_options: AgentCapabilityOptions {
                terminal: config
                    .terminal
                    .enabled
                    .then_some(TerminalCapabilityOptions {
                        max_sessions: config.terminal.max_sessions.max(1),
                        session_ttl_seconds: config.terminal.session_ttl_seconds,
                    }),
            },
        },
    )
    .await?;
@@ -82,6 +105,7 @@ async fn run_once(config: &AgentConfig) -> Result<()> {
        },
    )
    .await?;
    send_terminal_sessions(&mut sink, terminal_manager).await?;
    info!(agent_id = %config.agent_id, "agent websocket session authenticated");
    let mut heartbeat = interval(Duration::from_secs(30));
@@ -91,9 +115,21 @@ async fn run_once(config: &AgentConfig) -> Result<()> {
    ));
    snapshot_sync.set_missed_tick_behavior(MissedTickBehavior::Skip);
    snapshot_sync.reset();
    loop {
        tokio::select! {
            Some(event) = terminal_events.recv() => {
                send_json(
                    &mut sink,
                    &ClientMessage::TerminalRejected {
                            terminal_id: event.terminal_id,
                        error: ErrorPayload {
                            code: "terminal_worker_failed".into(),
                            message: event.error,
                            retryable: Some(false),
                        },
                    },
                ).await?;
            }
            _ = heartbeat.tick() => {
                send_json(&mut sink, &ClientMessage::Heartbeat {
                    agent_id: config.agent_id.clone(),
@@ -118,7 +154,7 @@ async fn run_once(config: &AgentConfig) -> Result<()> {
                    Message::Text(text) => {
                        match serde_json::from_str::<ServerMessage>(&text) {
                            Ok(message) => {
-                                handle_server_message(config, &mut sink, &mut snapshot_sync, message).await?;
+                handle_server_message(config, terminal_manager, &mut sink, &mut snapshot_sync, message).await?;
                            }
                            Err(err) => {
                                // Allow the server to introduce extra frame types without
@@ -145,13 +181,34 @@ async fn run_once(config: &AgentConfig) -> Result<()> {
    }
 }
 async fn send_terminal_sessions<S>(sink: &mut S, manager: &TerminalManager) -> Result<()>
 where
    S: SinkExt<Message> + Unpin,
    <S as futures_util::Sink<Message>>::Error: std::error::Error + Send + Sync + 'static,
 {
    send_json(
        sink,
        &ClientMessage::TerminalSessions {
            sessions: manager.sessions(),
        },
    )
    .await
 }
 async fn send_device_snapshot_ws<S>(sink: &mut S, config: &AgentConfig) -> Result<usize>
 where
    S: SinkExt<Message> + Unpin,
    <S as futures_util::Sink<Message>>::Error: std::error::Error + Send + Sync + 'static,
 {
-    let query = wakey_core::InventoryQueryBuilder::new().build();
+    let req = crate::protocol::InventoryRequest {
-    let inventory = wakey::inventory(query)
+        query: None,
        name: None,
        ips: Vec::new(),
        devs: Vec::new(),
        nuds: Vec::new(),
        macs: Vec::new(),
    };
    let inventory = inventory_for_config(req, config)
        .await
        .context("failed to run inventory for device snapshot")?;
    let count = inventory.devices.len();
@@ -174,6 +231,7 @@ pub fn next_backoff_ms(current_ms: u64, max_ms: u64) -> u64 {
 async fn handle_server_message<S>(
    config: &AgentConfig,
    terminal_manager: &TerminalManager,
    sink: &mut S,
    snapshot_sync: &mut tokio::time::Interval,
    message: ServerMessage,
@@ -216,6 +274,48 @@ where
            send_device_snapshot_ws(sink, config).await?;
            snapshot_sync.reset();
        }
        ServerMessage::SyncTerminalSessions => {
            send_terminal_sessions(sink, terminal_manager).await?;
        }
        ServerMessage::OpenTerminal {
            terminal_id,
            relay_token,
            rows,
            cols,
        } => {
            info!(terminal_id = %terminal_id, rows, cols, "received terminal open request");
            if let Err(err) =
                terminal_manager.open(config, terminal_id.clone(), relay_token, rows, cols)
            {
                error!(terminal_id = %terminal_id, error = %err, "terminal open request rejected");
                send_json(
                    sink,
                    &ClientMessage::TerminalRejected {
                        terminal_id,
                        error: ErrorPayload {
                            code: "terminal_open_rejected".into(),
                            message: err.to_string(),
                            retryable: Some(false),
                        },
                    },
                )
                .await?;
            }
        }
        ServerMessage::CloseTerminal { terminal_id } => {
            info!(terminal_id = %terminal_id, "received terminal close request");
            terminal_manager.close(&terminal_id);
        }
        ServerMessage::ResumeTerminal {
            terminal_id,
            relay_token,
        } => {
            info!(terminal_id = %terminal_id, "received terminal relay resume request");
            if let Err(err) = terminal_manager.resume(&terminal_id, relay_token) {
                warn!(terminal_id = %terminal_id, error = %err, "terminal relay resume rejected");
                send_terminal_sessions(sink, terminal_manager).await?;
            }
        }
    }
    Ok(())
 }
@@ -294,9 +394,20 @@ fn client_message_kind(message: &ClientMessage) -> &'static str {
        ClientMessage::DeviceSnapshot { .. } => "device_snapshot",
        ClientMessage::Result { .. } => "result",
        ClientMessage::Error { .. } => "error",
        ClientMessage::TerminalRejected { .. } => "terminal_rejected",
        ClientMessage::TerminalSessions { .. } => "terminal_sessions",
    }
 }
 fn agent_capabilities(config: &AgentConfig) -> Vec<AgentCapability> {
    #[cfg(unix)]
    if config.terminal.enabled {
        return vec![AgentCapability::Terminal];
    }
    Vec::new()
 }
 pub fn websocket_url(server_url: &str) -> Result<url::Url> {
    let base = url::Url::parse(server_url).context("invalid server_url")?;
    let scheme = match base.scheme() {
@@ -1,6 +1,6 @@
 [package]
 name = "wakey-control-plane"
-version = "0.3.0"
+version = "0.3.5"
 edition = "2024"
 publish = ["gitea"]
@@ -0,0 +1,22 @@
 CREATE TABLE agent_device_endpoints (
    agent_id TEXT NOT NULL,
    device_key TEXT NOT NULL,
    endpoint_key TEXT NOT NULL,
    source TEXT NOT NULL,
    mac TEXT,
    ip TEXT,
    hostname TEXT,
    interface TEXT,
    presence TEXT NOT NULL,
    first_seen_unix INTEGER NOT NULL,
    last_seen_unix INTEGER NOT NULL,
    PRIMARY KEY (agent_id, device_key, endpoint_key),
    FOREIGN KEY (agent_id, device_key)
        REFERENCES agent_devices(agent_id, device_key) ON DELETE CASCADE
 ) WITHOUT ROWID;
 CREATE INDEX agent_device_endpoints_mac_idx
    ON agent_device_endpoints(mac);
 CREATE INDEX agent_device_endpoints_ip_idx
    ON agent_device_endpoints(ip);
@@ -6,7 +6,9 @@ use serde::{Deserialize, Serialize};
 use std::time::Instant;
 use tracing::{info, info_span, warn};
 use uuid::Uuid;
-use wakey_agent::protocol::{AgentCommand, ErrorPayload, RequestId, ServerMessage};
+use wakey_agent::protocol::{
    AgentCapability, AgentCapabilityOptions, AgentCommand, ErrorPayload, RequestId, ServerMessage,
 };
 use crate::api::ApiError;
 use crate::runtime::{AgentReply, AppState, SessionEvent};
@@ -17,6 +19,8 @@ pub struct AgentStatus {
    pub agent_id: String,
    pub connected: bool,
    pub nickname: Option<String>,
    pub capabilities: Vec<AgentCapability>,
    pub capability_options: AgentCapabilityOptions,
 }
 #[derive(Debug, Deserialize)]
@@ -43,6 +47,14 @@ pub async fn list_agents(State(state): State<AppState>) -> Result<impl IntoRespo
        .into_iter()
        .map(|(agent_id, nickname)| AgentStatus {
            connected: sessions.contains_key(&agent_id),
            capabilities: sessions
                .get(&agent_id)
                .map(|session| session.capabilities.clone())
                .unwrap_or_default(),
            capability_options: sessions
                .get(&agent_id)
                .map(|session| session.capability_options.clone())
                .unwrap_or_default(),
            agent_id,
            nickname,
        })
@@ -5,7 +5,7 @@ mod stats;
 pub use devices::{
    attach_device_identifier, create_known_device, detach_device_identifier, forget_known_device,
-    list_known_devices, merge_known_device,
+    get_known_device, list_known_devices, merge_known_device,
 };
 pub use enroll::{
    EnrollTokenStatus, IssueEnrollTokenResponse, RevokeAgentResponse, RevokeEnrollTokenResponse,
@@ -111,6 +111,28 @@ pub async fn list_known_devices(
    }
 }
 pub async fn get_known_device(
    State(state): State<AppState>,
    AxumPath(device_id): AxumPath<String>,
 ) -> Result<impl IntoResponse, ApiError> {
    match state.store.get_known_device(&device_id).await {
        Ok(Some(device)) => Ok((StatusCode::OK, Json(known_device_response(device)))),
        Ok(None) => Err(ApiError::new(
            StatusCode::NOT_FOUND,
            "known_device_not_found",
            "known device not found",
        )),
        Err(err) => {
            warn!(error = %err, "failed to get known device");
            Err(ApiError::new(
                StatusCode::INTERNAL_SERVER_ERROR,
                "get_known_device_failed",
                err.to_string(),
            ))
        }
    }
 }
 pub async fn forget_known_device(
    State(state): State<AppState>,
    AxumPath(device_id): AxumPath<String>,
@@ -2,11 +2,13 @@ use std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::net::IpAddr;
 use macaddr::MacAddr;
-use wakey_core::Presence;
+use wakey_core::{EndpointSource, Presence};
 use crate::state::{AgentDeviceWithChildren, DeviceIdentifier, KnownDevice, KnownDeviceSummary};
-use super::types::{FleetDevice, FleetDeviceAgent, FleetWakeRoute, ListFleetDevicesQuery};
+use super::types::{
    FleetDevice, FleetDeviceAgent, FleetDeviceEndpoint, FleetWakeRoute, ListFleetDevicesQuery,
 };
 #[derive(Debug, Default)]
 pub(crate) struct FleetBuildContext {
@@ -31,6 +33,7 @@ struct FleetAccumulator {
    hostnames: BTreeSet<String>,
    sources: BTreeSet<String>,
    agents: BTreeMap<String, FleetDeviceAgent>,
    endpoints: Vec<FleetDeviceEndpoint>,
    first_seen_unix: Option<u64>,
    last_seen_unix: Option<u64>,
    presence: Presence,
@@ -49,6 +52,7 @@ impl Default for FleetAccumulator {
            hostnames: BTreeSet::new(),
            sources: BTreeSet::new(),
            agents: BTreeMap::new(),
            endpoints: Vec::new(),
            first_seen_unix: None,
            last_seen_unix: None,
            presence: Presence::Offline,
@@ -199,6 +203,7 @@ fn add_agent_device_to_entry(
        entry.pinned = summary.pinned;
        entry.known_device = Some(summary);
    }
    if agent_device.endpoints.is_empty() {
        for mac in &agent_device.macs {
            entry.macs.insert(*mac);
        }
@@ -207,13 +212,24 @@ fn add_agent_device_to_entry(
                entry.ips.insert(*ip);
            }
        }
    } else {
        for endpoint in &agent_device.endpoints {
            if let Some(mac) = endpoint.key.mac {
                entry.macs.insert(mac);
            }
            if endpoint_ip_is_summary_eligible(endpoint.key.source, endpoint.presence)
                && let Some(ip) = endpoint.key.ip
            {
                entry.ips.insert(ip);
            }
        }
    }
    for hostname in &agent_device.hostnames {
        if entry.display_name.is_none() {
            entry.display_name = Some(hostname.clone());
        }
        entry.hostnames.insert(hostname.clone());
    }
    entry.sources.insert("device".to_string());
    let first_seen = agent_device.device.first_seen();
    let last_seen = agent_device.device.last_seen();
    entry.first_seen_unix = Some(
@@ -255,13 +271,62 @@ fn add_agent_device_to_entry(
            last_seen_unix: last_seen,
        });
    if agent_device.endpoints.is_empty() {
        entry.sources.insert("device".to_string());
    }
    for endpoint in &agent_device.endpoints {
        let source = endpoint_source_label(endpoint.key.source).to_string();
        entry.sources.insert(source.clone());
        let endpoint_last_seen = endpoint.last_seen_unix.unwrap_or(last_seen);
        let endpoint_first_seen = endpoint.first_seen_unix.or(Some(first_seen));
        entry.endpoints.push(FleetDeviceEndpoint {
            agent_id: agent_id.clone(),
            nickname: status.nickname.clone(),
            connected: status.connected,
            source: source.clone(),
            mac: endpoint.key.mac,
            ip: endpoint.key.ip,
            hostname: endpoint.hostname.clone(),
            interface: endpoint.interface.clone(),
            presence: endpoint.presence,
            first_seen_unix: endpoint_first_seen,
            last_seen_unix: Some(endpoint_last_seen),
        });
        let rid = route_id(
            &agent_id,
            endpoint.key.mac.as_ref(),
            endpoint.key.ip.as_ref(),
        );
        let wakeable = status.connected && endpoint.key.mac.is_some();
        insert_route(
            entry,
            FleetWakeRoute {
                route_id: rid,
                agent_id: agent_id.clone(),
                nickname: status.nickname.clone(),
                connected: status.connected,
                mac: endpoint.key.mac,
                ip: endpoint.key.ip,
                hostname: endpoint.hostname.clone(),
                interface: endpoint.interface.clone(),
                source,
                presence: endpoint.presence,
                last_seen_unix: endpoint_last_seen,
                wakeable,
            },
        );
    }
    if agent_device.endpoints.is_empty() && !agent_device.macs.is_empty() {
        for mac in &agent_device.macs {
            let ip_for_mac = agent_device.ips.first().copied();
            let hostname_for_mac = agent_device.hostnames.first().cloned();
-        let rid = route_id(&agent_id, Some(mac), ip_for_mac.as_ref(), "device");
+            let rid = route_id(&agent_id, Some(mac), ip_for_mac.as_ref());
-        let wakeable = status.connected && !device_offline;
+            let wakeable = status.connected;
-        entry.routes.insert(
+            insert_route(
-            rid.clone(),
+                entry,
                FleetWakeRoute {
                    route_id: rid,
                    agent_id: agent_id.clone(),
@@ -270,20 +335,24 @@ fn add_agent_device_to_entry(
                    mac: Some(*mac),
                    ip: ip_for_mac,
                    hostname: hostname_for_mac,
                    interface: None,
                    source: "device".to_string(),
                    presence: device_presence,
                    last_seen_unix: last_seen,
                    wakeable,
                },
            );
        }
    }
-    if agent_device.macs.is_empty()
+    if agent_device.endpoints.is_empty()
        && agent_device.macs.is_empty()
        && let Some(ip) = agent_device.ips.first()
    {
        let hostname = agent_device.hostnames.first().cloned();
-        let rid = route_id(&agent_id, None, Some(ip), "device");
+        let rid = route_id(&agent_id, None, Some(ip));
-        entry.routes.insert(
+        insert_route(
-            rid.clone(),
+            entry,
            FleetWakeRoute {
                route_id: rid,
                agent_id: agent_id.clone(),
@@ -292,7 +361,9 @@ fn add_agent_device_to_entry(
                mac: None,
                ip: Some(*ip),
                hostname,
                interface: None,
                source: "device".to_string(),
                presence: device_presence,
                last_seen_unix: last_seen,
                wakeable: false,
            },
@@ -321,19 +392,66 @@ fn device_known_device(
    context: &FleetBuildContext,
 ) -> Option<KnownDeviceSummary> {
    agent_device
-        .macs
+        .endpoints
-        .first()
+        .iter()
        .filter_map(|endpoint| endpoint.key.mac)
        .map(|mac| format!("mac:{}", mac.to_string().to_ascii_lowercase()))
-        .and_then(|key| context.identifier_map.get(&key).cloned())
+        .find_map(|key| context.identifier_map.get(&key).cloned())
        .or_else(|| {
            agent_device
                .macs
                .iter()
                .map(|mac| format!("mac:{}", mac.to_string().to_ascii_lowercase()))
                .find_map(|key| context.identifier_map.get(&key).cloned())
        })
        .or_else(|| {
            agent_device
                .endpoints
                .iter()
                .filter_map(|endpoint| endpoint.key.ip)
                .map(|ip| format!("ip:{ip}"))
                .find_map(|key| context.identifier_map.get(&key).cloned())
        })
        .or_else(|| {
            agent_device
                .ips
-                .first()
+                .iter()
                .map(|ip| format!("ip:{ip}"))
-                .and_then(|key| context.identifier_map.get(&key).cloned())
+                .find_map(|key| context.identifier_map.get(&key).cloned())
        })
 }
 fn endpoint_ip_is_summary_eligible(source: EndpointSource, presence: Presence) -> bool {
    match source {
        EndpointSource::DhcpLease => true,
        EndpointSource::Neighbor => presence != Presence::Offline,
        EndpointSource::HookNeighbor | EndpointSource::HookDhcp => false,
    }
 }
 fn insert_route(entry: &mut FleetAccumulator, candidate: FleetWakeRoute) {
    match entry.routes.entry(candidate.route_id.clone()) {
        std::collections::btree_map::Entry::Vacant(slot) => {
            slot.insert(candidate);
        }
        std::collections::btree_map::Entry::Occupied(mut slot) => {
            if compare_route_quality(&candidate, slot.get()).is_gt() {
                slot.insert(candidate);
            }
        }
    }
 }
 fn compare_route_quality(a: &FleetWakeRoute, b: &FleetWakeRoute) -> std::cmp::Ordering {
    a.connected
        .cmp(&b.connected)
        .then_with(|| a.wakeable.cmp(&b.wakeable))
        .then_with(|| a.ip.is_some().cmp(&b.ip.is_some()))
        .then_with(|| a.presence.cmp(&b.presence))
        .then_with(|| a.last_seen_unix.cmp(&b.last_seen_unix))
        .then_with(|| source_quality_rank(&a.source).cmp(&source_quality_rank(&b.source)))
 }
 pub(crate) fn known_device_summary(device: &KnownDevice) -> KnownDeviceSummary {
    KnownDeviceSummary {
        device_id: device.device_id.clone(),
@@ -345,13 +463,8 @@ pub(crate) fn known_device_summary(device: &KnownDevice) -> KnownDeviceSummary {
 impl FleetAccumulator {
    fn into_response(self) -> FleetDevice {
        let mut route_candidates = self.routes.into_values().collect::<Vec<_>>();
-        route_candidates.sort_by(|a, b| {
+        route_candidates
-            b.connected
+            .sort_by(|a, b| compare_route_quality(b, a).then_with(|| a.agent_id.cmp(&b.agent_id)));
                .cmp(&a.connected)
                .then_with(|| b.wakeable.cmp(&a.wakeable))
                .then_with(|| b.last_seen_unix.cmp(&a.last_seen_unix))
                .then_with(|| a.agent_id.cmp(&b.agent_id))
        });
        let recommended_route = route_candidates
            .iter()
            .find(|route| route.wakeable)
@@ -373,6 +486,7 @@ impl FleetAccumulator {
            hostnames: self.hostnames.into_iter().collect(),
            agents: self.agents.into_values().collect(),
            sources: self.sources.into_iter().collect(),
            endpoints: self.endpoints,
            first_seen_unix: self.first_seen_unix,
            last_seen_unix: self.last_seen_unix,
            presence: self.presence,
@@ -382,11 +496,29 @@ impl FleetAccumulator {
    }
 }
-fn route_id(agent_id: &str, mac: Option<&MacAddr>, ip: Option<&IpAddr>, source: &str) -> String {
+fn endpoint_source_label(source: EndpointSource) -> &'static str {
    match source {
        EndpointSource::Neighbor => "neighbor",
        EndpointSource::DhcpLease => "dhcp_lease",
        EndpointSource::HookNeighbor => "hook_neighbor",
        EndpointSource::HookDhcp => "hook_dhcp",
    }
 }
 fn source_quality_rank(source: &str) -> u8 {
    match source {
        "neighbor" => 4,
        "dhcp_lease" => 3,
        "hook_neighbor" => 2,
        "hook_dhcp" => 1,
        _ => 0,
    }
 }
 fn route_id(agent_id: &str, mac: Option<&MacAddr>, ip: Option<&IpAddr>) -> String {
    format!(
-        "{}|{}|{}|{}",
+        "{}|{}|{}",
        agent_id,
        source,
        mac.map(|m| m.to_string()).unwrap_or_default(),
        ip.map(|i| i.to_string()).unwrap_or_default()
    )
@@ -85,12 +85,9 @@ pub async fn refresh_fleet_devices(
                    });
                    continue;
                };
-                match serde_json::from_value::<Vec<wakey_core::Device>>(
+                match serde_json::from_value::<wakey_core::DeviceInventory>(result)
-                    result
+                    .map(|i| i.devices)
-                        .get("devices")
+                {
                        .cloned()
                        .unwrap_or(serde_json::Value::Array(vec![])),
                ) {
                    Ok(devices) => {
                        match state
                            .store
@@ -276,6 +273,7 @@ async fn load_fleet_devices(
    let mut devices = build_fleet_devices(known_devices, agent_devices, &context);
    filter_fleet_devices(&mut devices, query);
    let limit = query.limit.unwrap_or(500).clamp(1, 1000);
    // this is going to be 10 million times harder if i decide to do this lazily
    devices.truncate(limit);
    Ok(devices)
 }
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::net::IpAddr;
 use macaddr::MacAddr;
-use wakey_core::Presence;
+use wakey_core::{DeviceEndpoint, EndpointKey, EndpointSource, Presence};
 use super::build::{
    AgentRuntimeStatus, FleetBuildContext, build_fleet_devices, filter_fleet_devices,
@@ -54,6 +54,7 @@ fn agent_device(
            .into_iter()
            .collect(),
        hostnames: vec!["lda".to_string()],
        endpoints: vec![],
        facts: vec![],
    }
 }
@@ -83,6 +84,7 @@ fn offline_agent_device(
            .into_iter()
            .collect(),
        hostnames: vec!["lda".to_string()],
        endpoints: vec![],
        facts: vec![],
    }
 }
@@ -105,10 +107,42 @@ fn offline_ip_only_unknown(
        macs: vec![],
        ips: vec![ip.parse().unwrap()],
        hostnames: vec![],
        endpoints: vec![],
        facts: vec![],
    }
 }
 fn endpoint(
    source: EndpointSource,
    mac: Option<&str>,
    ip: Option<&str>,
    last_seen_unix: u64,
 ) -> DeviceEndpoint {
    endpoint_with_presence(source, mac, ip, Presence::LikelyOnline, last_seen_unix)
 }
 fn endpoint_with_presence(
    source: EndpointSource,
    mac: Option<&str>,
    ip: Option<&str>,
    presence: Presence,
    last_seen_unix: u64,
 ) -> DeviceEndpoint {
    DeviceEndpoint {
        key: EndpointKey::new(
            source,
            mac.map(|m| m.parse::<MacAddr>().unwrap()),
            ip.map(|i| i.parse::<IpAddr>().unwrap()),
        )
        .expect("endpoint key"),
        hostname: Some("lda".into()),
        interface: Some("br-lan".into()),
        presence,
        first_seen_unix: Some(1),
        last_seen_unix: Some(last_seen_unix),
    }
 }
 #[test]
 fn fleet_grouping_combines_same_mac_across_agents() {
    let devices = build_fleet_devices(
@@ -145,6 +179,146 @@ fn fleet_grouping_combines_same_mac_across_agents() {
    );
 }
 #[test]
 fn fleet_routes_use_endpoint_mac_ip_pairs() {
    let mac = "aa:bb:cc:dd:ee:ff";
    let mut row = agent_device(
        "agent-a",
        "mac:aa:bb:cc:dd:ee:ff",
        Some(mac),
        Some("192.168.1.2"),
        20,
    );
    row.endpoints = vec![
        endpoint(
            EndpointSource::HookNeighbor,
            Some(mac),
            Some("192.168.1.2"),
            10,
        ),
        endpoint(EndpointSource::Neighbor, Some(mac), Some("192.168.1.3"), 20),
    ];
    let devices = build_fleet_devices(Vec::new(), vec![row], &context(&["agent-a"]));
    assert_eq!(devices.len(), 1);
    assert_eq!(devices[0].endpoints.len(), 2);
    assert_eq!(devices[0].route_candidates.len(), 2);
    assert_eq!(
        devices[0]
            .recommended_route
            .as_ref()
            .and_then(|route| route.ip),
        Some("192.168.1.3".parse().unwrap())
    );
 }
 #[test]
 fn fleet_summary_keeps_current_dhcp_ip_when_neighbor_endpoint_is_offline() {
    let mac = "aa:bb:cc:dd:ee:ff";
    let mut row = offline_agent_device(
        "agent-a",
        "mac:aa:bb:cc:dd:ee:ff",
        Some(mac),
        Some("192.168.1.99"),
        20,
    );
    row.ips = vec![
        "192.168.1.10".parse().unwrap(),
        "192.168.1.99".parse().unwrap(),
    ];
    row.endpoints = vec![
        endpoint_with_presence(
            EndpointSource::Neighbor,
            Some(mac),
            Some("192.168.1.99"),
            Presence::Offline,
            20,
        ),
        endpoint_with_presence(
            EndpointSource::DhcpLease,
            Some(mac),
            Some("192.168.1.10"),
            Presence::Unknown,
            20,
        ),
    ];
    let devices = build_fleet_devices(Vec::new(), vec![row], &context(&["agent-a"]));
    assert_eq!(devices.len(), 1);
    assert_eq!(
        devices[0].ips,
        vec!["192.168.1.10".parse::<IpAddr>().unwrap()]
    );
 }
 #[test]
 fn known_ip_identifier_matches_endpoint_that_is_not_in_summary_ips() {
    let known = KnownDevice {
        device_id: "dev-1".into(),
        display_name: "lda remembered".into(),
        pinned: true,
        created_at_unix: 1,
        updated_at_unix: 1,
        notes: None,
        identifiers: vec![DeviceIdentifier {
            identifier_key: "ip:192.168.1.99".into(),
            device_id: "dev-1".into(),
            kind: "ip".into(),
            value: "192.168.1.99".into(),
            created_at_unix: 1,
        }],
    };
    let mut ctx = context(&["agent-a"]);
    ctx.identifier_map
        .insert("ip:192.168.1.99".into(), known_device_summary(&known));
    let mut row = agent_device("agent-a", "ip:192.168.1.99", None, None, 20);
    row.endpoints = vec![endpoint_with_presence(
        EndpointSource::HookNeighbor,
        None,
        Some("192.168.1.99"),
        Presence::Offline,
        20,
    )];
    let devices = build_fleet_devices(vec![known], vec![row], &ctx);
    assert_eq!(devices.len(), 1);
    assert_eq!(devices[0].device_key, "known:dev-1");
    assert_eq!(devices[0].endpoints.len(), 1);
 }
 #[test]
 fn equivalent_endpoint_routes_collapse_to_best_source() {
    let mac = "aa:bb:cc:dd:ee:ff";
    let ip = "192.168.1.2";
    let mut row = agent_device("agent-a", "mac:aa:bb:cc:dd:ee:ff", Some(mac), Some(ip), 20);
    row.endpoints = vec![
        endpoint_with_presence(
            EndpointSource::HookNeighbor,
            Some(mac),
            Some(ip),
            Presence::LikelyOnline,
            20,
        ),
        endpoint_with_presence(
            EndpointSource::Neighbor,
            Some(mac),
            Some(ip),
            Presence::Online,
            20,
        ),
    ];
    let devices = build_fleet_devices(Vec::new(), vec![row], &context(&["agent-a"]));
    assert_eq!(devices[0].endpoints.len(), 2);
    assert_eq!(devices[0].route_candidates.len(), 1);
    assert_eq!(devices[0].route_candidates[0].source, "neighbor");
    assert_eq!(devices[0].route_candidates[0].presence, Presence::Online);
 }
 #[test]
 fn known_device_with_two_macs_absorbs_both_device_groups() {
    let known = KnownDevice {
@@ -242,7 +416,7 @@ fn offline_device_has_offline_presence() {
    assert_eq!(devices.len(), 1);
    assert!(devices[0].ips.is_empty());
    assert_eq!(devices[0].presence, Presence::Offline);
-    assert!(devices[0].recommended_route.is_none());
+    assert!(devices[0].recommended_route.is_some());
 }
 #[test]
@@ -68,6 +68,7 @@ pub struct FleetDevice {
    pub hostnames: Vec<String>,
    pub agents: Vec<FleetDeviceAgent>,
    pub sources: Vec<String>,
    pub endpoints: Vec<FleetDeviceEndpoint>,
    pub first_seen_unix: Option<u64>,
    pub last_seen_unix: Option<u64>,
    pub presence: Presence,
@@ -83,6 +84,22 @@ pub struct FleetDeviceAgent {
    pub last_seen_unix: u64,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FleetDeviceEndpoint {
    pub agent_id: String,
    pub nickname: Option<String>,
    pub connected: bool,
    pub source: String,
    #[serde(with = "mac::option_mac")]
    pub mac: Option<MacAddr>,
    pub ip: Option<IpAddr>,
    pub hostname: Option<String>,
    pub interface: Option<String>,
    pub presence: Presence,
    pub first_seen_unix: Option<u64>,
    pub last_seen_unix: Option<u64>,
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FleetWakeRoute {
    pub route_id: String,
@@ -93,7 +110,9 @@ pub struct FleetWakeRoute {
    pub mac: Option<MacAddr>,
    pub ip: Option<IpAddr>,
    pub hostname: Option<String>,
    pub interface: Option<String>,
    pub source: String,
    pub presence: Presence,
    pub last_seen_unix: u64,
    pub wakeable: bool,
 }
@@ -5,6 +5,7 @@ mod alerts;
 mod audit;
 mod commands;
 mod control;
 mod terminals;
 pub use alerts::{active_alerts, alert_history, alerts_stream};
 pub use audit::list_audit_events;
@@ -12,10 +13,14 @@ pub use commands::{list_agents, run_command};
 pub use control::{
    EnrollTokenStatus, IssueEnrollTokenResponse, RevokeAgentResponse, RevokeEnrollTokenResponse,
    StateStatsResponse, attach_device_identifier, create_known_device, detach_device_identifier,
-    enroll, forget_known_device, healthz, issue_enroll_token, list_enroll_tokens,
+    enroll, forget_known_device, get_known_device, healthz, issue_enroll_token, list_enroll_tokens,
    list_fleet_devices, list_known_devices, merge_known_device, refresh_fleet_devices,
    revoke_agent, revoke_enroll_token, set_agent_nickname, state_stats, wake_fleet_device,
 };
 pub use terminals::{
    agent_terminal_ws, attach_terminal, close_terminal, create_terminal, get_terminal,
    list_terminals, operator_terminal_ws,
 };
 use axum::response::{IntoResponse, Response};
 use serde::{Deserialize, Serialize};
@@ -0,0 +1,730 @@
 use axum::Json;
 use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade};
 use axum::extract::{Path, State};
 use axum::http::StatusCode;
 use axum::response::Response;
 use futures_util::{SinkExt, StreamExt};
 use serde::{Deserialize, Serialize};
 use std::time::Duration;
 use tracing::{info, warn};
 use wakey_agent::protocol::{
    AgentCapability, DEFAULT_TERMINAL_MAX_SESSIONS, DEFAULT_TERMINAL_SESSION_TTL_SECONDS,
    ServerMessage, TerminalAgentHandshake, TerminalControl, TerminalId, TerminalOperatorHandshake,
 };
 use crate::api::ApiError;
 use crate::runtime::terminals::{
    TERMINAL_ATTACH_TIMEOUT, TERMINAL_MAX_FRAME_BYTES, TerminalRelayFrame, TerminalSummary,
 };
 use crate::runtime::{AppState, SessionEvent};
 use crate::state::AuditEventInput;
 #[derive(Debug, Deserialize)]
 pub struct CreateTerminalRequest {
    pub agent_id: String,
    #[serde(default = "default_rows")]
    pub rows: u16,
    #[serde(default = "default_cols")]
    pub cols: u16,
 }
 #[derive(Debug, Deserialize)]
 pub struct AttachTerminalRequest {
    /// Stable for one browser tab, allowing CC to distinguish a stale socket
    /// owned by this tab from a session open in another browser.
    pub operator_id: String,
 }
 #[derive(Debug, Serialize)]
 pub struct TerminalSessionResponse {
    pub terminal_id: String,
    pub agent_id: String,
    pub created_at_unix: u64,
    pub expires_at_unix: Option<u64>,
    pub agent_attached: bool,
    pub operator_attached: bool,
    pub websocket_url: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attachment_token: Option<String>,
 }
 pub async fn create_terminal(
    State(state): State<AppState>,
    Json(request): Json<CreateTerminalRequest>,
 ) -> Result<(StatusCode, Json<TerminalSessionResponse>), ApiError> {
    validate_size(request.rows, request.cols)?;
    let (agent_tx, max_sessions, session_ttl_seconds) = {
        let sessions = state.sessions.read().await;
        let session = sessions.get(&request.agent_id).ok_or_else(|| {
            ApiError::new(
                StatusCode::NOT_FOUND,
                "agent_not_connected",
                "agent is not connected",
            )
        })?;
        if !session.capabilities.contains(&AgentCapability::Terminal) {
            return Err(ApiError::new(
                StatusCode::CONFLICT,
                "terminal_not_supported",
                "agent has not advertised terminal capability",
            ));
        }
        let max_sessions = session
            .capability_options
            .terminal
            .as_ref()
            .map(|terminal| terminal.max_sessions)
            .unwrap_or(DEFAULT_TERMINAL_MAX_SESSIONS)
            .max(1);
        let session_ttl_seconds = session
            .capability_options
            .terminal
            .as_ref()
            .map(|terminal| terminal.session_ttl_seconds)
            .unwrap_or(DEFAULT_TERMINAL_SESSION_TTL_SECONDS);
        (session.tx.clone(), max_sessions, session_ttl_seconds)
    };
    let created = state
        .terminals
        .create_with_limits(request.agent_id.clone(), max_sessions, session_ttl_seconds)
        .await
        .map_err(registry_error)?;
    let terminal_id = TerminalId::new(created.terminal_id.clone()).map_err(|message| {
        ApiError::new(
            StatusCode::INTERNAL_SERVER_ERROR,
            "terminal_id_invalid",
            message,
        )
    })?;
    if agent_tx
        .send(SessionEvent::Message(ServerMessage::OpenTerminal {
            terminal_id: terminal_id.clone(),
            relay_token: created.relay_token,
            rows: request.rows,
            cols: request.cols,
        }))
        .is_err()
    {
        state.terminals.remove(terminal_id.as_str()).await;
        return Err(ApiError::new(
            StatusCode::BAD_GATEWAY,
            "agent_send_failed",
            "failed to send terminal request to agent",
        ));
    }
    spawn_session_timeout(
        state.clone(),
        terminal_id.clone(),
        request.agent_id.clone(),
        session_ttl_seconds,
    );
    append_terminal_audit(
        &state,
        &request.agent_id,
        terminal_id.as_str(),
        TerminalAudit {
            actor_type: "admin_api",
            event_type: "terminal_request",
            outcome: "sent",
            message: "terminal session requested",
            metadata: serde_json::json!({ "rows": request.rows, "cols": request.cols }),
        },
    )
    .await;
    info!(terminal_id = %terminal_id, agent_id = %request.agent_id, "terminal session requested");
    Ok((
        StatusCode::CREATED,
        Json(TerminalSessionResponse {
            websocket_url: operator_ws_path(terminal_id.as_str()),
            terminal_id: terminal_id.to_string(),
            agent_id: request.agent_id,
            created_at_unix: created.created_at_unix,
            expires_at_unix: created.expires_at_unix,
            agent_attached: false,
            operator_attached: false,
            attachment_token: Some(created.attachment_token),
        }),
    ))
 }
 pub async fn get_terminal(
    State(state): State<AppState>,
    Path(terminal_id): Path<String>,
 ) -> Result<Json<TerminalSessionResponse>, ApiError> {
    let summary = state
        .terminals
        .summary(&terminal_id)
        .await
        .ok_or_else(|| terminal_not_found(&terminal_id))?;
    Ok(Json(TerminalSessionResponse {
        websocket_url: operator_ws_path(&terminal_id),
        terminal_id,
        agent_id: summary.agent_id,
        created_at_unix: summary.created_at_unix,
        expires_at_unix: summary.expires_at_unix,
        agent_attached: summary.agent_attached,
        operator_attached: summary.operator_attached,
        attachment_token: None,
    }))
 }
 pub async fn list_terminals(State(state): State<AppState>) -> Json<Vec<TerminalSessionResponse>> {
    Json(
        state
            .terminals
            .summaries()
            .await
            .into_iter()
            .map(terminal_response)
            .collect(),
    )
 }
 pub async fn attach_terminal(
    State(state): State<AppState>,
    Path(terminal_id): Path<String>,
    Json(request): Json<AttachTerminalRequest>,
 ) -> Result<Json<TerminalSessionResponse>, ApiError> {
    let attachment_token = state
        .terminals
        .issue_attachment_token_for_operator(&terminal_id, &request.operator_id)
        .await
        .map_err(registry_error)?;
    let summary = state
        .terminals
        .summary(&terminal_id)
        .await
        .ok_or_else(|| terminal_not_found(&terminal_id))?;
    Ok(Json(TerminalSessionResponse {
        websocket_url: operator_ws_path(&terminal_id),
        terminal_id,
        agent_id: summary.agent_id,
        created_at_unix: summary.created_at_unix,
        expires_at_unix: summary.expires_at_unix,
        agent_attached: summary.agent_attached,
        operator_attached: summary.operator_attached,
        attachment_token: Some(attachment_token),
    }))
 }
 pub async fn close_terminal(
    State(state): State<AppState>,
    Path(terminal_id): Path<String>,
 ) -> Result<StatusCode, ApiError> {
    if let Some(agent_id) =
        close_registered_terminal(&state, &terminal_id, TerminalCloseReason::HttpDelete).await
    {
        info!(terminal_id, agent_id, "terminal session closed by operator");
    } else {
        if !state.terminals.was_closed(&terminal_id).await {
            return Err(terminal_not_found(&terminal_id));
        }
        info!(terminal_id, "terminal session was already closed");
    }
    Ok(StatusCode::NO_CONTENT)
 }
 pub async fn agent_terminal_ws(
    ws: WebSocketUpgrade,
    State(state): State<AppState>,
    Path(terminal_id): Path<String>,
 ) -> Response {
    ws.max_message_size(TERMINAL_MAX_FRAME_BYTES)
        .on_upgrade(move |socket| handle_agent_terminal_socket(state, terminal_id, socket))
 }
 pub async fn operator_terminal_ws(
    ws: WebSocketUpgrade,
    State(state): State<AppState>,
    Path(terminal_id): Path<String>,
 ) -> Response {
    ws.max_message_size(TERMINAL_MAX_FRAME_BYTES)
        .on_upgrade(move |socket| handle_operator_terminal_socket(state, terminal_id, socket))
 }
 async fn handle_agent_terminal_socket(state: AppState, terminal_id: String, mut socket: WebSocket) {
    let auth = match receive_text_handshake(&mut socket).await.and_then(|text| {
        serde_json::from_str::<TerminalAgentHandshake>(&text).map_err(|_| "invalid handshake")
    }) {
        Ok(TerminalAgentHandshake::Auth {
            agent_id,
            relay_token,
        }) => (agent_id, relay_token),
        Err(code) => {
            close_socket(&mut socket, code).await;
            return;
        }
    };
    let (mut outbound, pending) = match state
        .terminals
        .attach_agent(&terminal_id, &auth.0, &auth.1)
        .await
    {
        Ok(outbound) => outbound,
        Err(code) => {
            close_socket(&mut socket, code).await;
            return;
        }
    };
    info!(terminal_id, agent_id = %auth.0, "agent terminal socket attached");
    append_terminal_audit(
        &state,
        &auth.0,
        &terminal_id,
        TerminalAudit {
            actor_type: "agent",
            event_type: "terminal_agent_attach",
            outcome: "ok",
            message: "agent terminal transport attached",
            metadata: serde_json::json!({}),
        },
    )
    .await;
    let (mut write, mut read) = socket.split();
    for frame in pending {
        let closes = matches!(frame, TerminalRelayFrame::Close);
        if send_relay_frame(&mut write, frame).await.is_err() || closes {
            state.terminals.remove(&terminal_id).await;
            return;
        }
    }
    loop {
        tokio::select! {
            biased;
            outbound_frame = outbound.recv() => {
                let Some(frame) = outbound_frame else { break; };
                if send_relay_frame(&mut write, frame).await.is_err() { break; }
            }
            incoming = read.next() => {
                let Some(Ok(message)) = incoming else { break; };
                match agent_relay_frame(message) {
                    Ok(Some(frame)) => {
                        let closes = matches!(frame, TerminalRelayFrame::Close);
                        audit_agent_control_frame(&state, &auth.0, &terminal_id, &frame).await;
                        if state.terminals.relay_from_agent(&terminal_id, frame).await.is_err() { break; }
                        if closes { break; }
                    }
                    Ok(None) => {}
                    Err(code) => {
                        warn!(terminal_id, code, "invalid agent terminal frame");
                        break;
                    }
                }
            }
        }
    }
    if let Some(agent_id) = state.terminals.detach_agent(&terminal_id).await
        && let Some(session) = state.sessions.read().await.get(&agent_id)
    {
        let _ = session
            .tx
            .send(SessionEvent::Message(ServerMessage::SyncTerminalSessions));
    }
    info!(terminal_id, "agent terminal relay detached");
 }
 async fn handle_operator_terminal_socket(
    state: AppState,
    terminal_id: String,
    mut socket: WebSocket,
 ) {
    let auth = match receive_text_handshake(&mut socket).await.and_then(|text| {
        serde_json::from_str::<TerminalOperatorHandshake>(&text).map_err(|_| "invalid handshake")
    }) {
        Ok(TerminalOperatorHandshake::Attach {
            attachment_token,
            operator_id,
        }) => (attachment_token, operator_id),
        Err(code) => {
            close_socket(&mut socket, code).await;
            return;
        }
    };
    let mut outbound = match state
        .terminals
        .attach_operator(&terminal_id, &auth.0, &auth.1)
        .await
    {
        Ok(attached) => attached,
        Err(code) => {
            close_socket(&mut socket, code).await;
            return;
        }
    };
    info!(terminal_id, "operator terminal socket attached");
    let snapshot = serde_json::to_string(&TerminalControl::Snapshot)
        .expect("terminal snapshot control serializes");
    if let Err(code) = state
        .terminals
        .relay_to_agent(&terminal_id, TerminalRelayFrame::Text(snapshot))
        .await
    {
        warn!(terminal_id, code, "failed to request terminal snapshot");
    }
    let summary = state.terminals.summary(&terminal_id).await;
    if let Some(summary) = &summary {
        append_terminal_audit(
            &state,
            &summary.agent_id,
            &terminal_id,
            TerminalAudit {
                actor_type: "admin_api",
                event_type: "terminal_operator_attach",
                outcome: "ok",
                message: "operator terminal transport attached",
                metadata: serde_json::json!({}),
            },
        )
        .await;
    }
    let (mut write, mut read) = socket.split();
    if summary.is_some_and(|summary| summary.agent_attached) {
        let ready = serde_json::to_string(&TerminalControl::Ready)
            .expect("terminal ready control serializes");
        if send_relay_frame(&mut write, TerminalRelayFrame::Text(ready))
            .await
            .is_err()
        {
            state.terminals.detach_operator(&terminal_id, &auth.0).await;
            return;
        }
    }
    let mut explicit_close = false;
    loop {
        tokio::select! {
            biased;
            incoming = read.next() => {
                let Some(Ok(message)) = incoming else { break; };
                match operator_relay_frame(message) {
                    Ok(Some(frame)) => {
                        explicit_close = matches!(frame, TerminalRelayFrame::Close);
                        if state.terminals.relay_to_agent(&terminal_id, frame).await.is_err() { break; }
                        if explicit_close { break; }
                    }
                    Ok(None) => {}
                    Err(code) => {
                        warn!(terminal_id, code, "invalid operator terminal frame");
                        break;
                    }
                }
            }
            outbound_frame = outbound.recv() => {
                let Some(frame) = outbound_frame else { break; };
                if send_relay_frame(&mut write, frame).await.is_err() { break; }
            }
        }
    }
    if explicit_close {
        close_registered_terminal(&state, &terminal_id, TerminalCloseReason::BrowserClose).await;
    } else {
        state.terminals.detach_operator(&terminal_id, &auth.0).await;
    }
    info!(
        terminal_id,
        explicit_close, "operator terminal socket detached"
    );
 }
 fn terminal_response(summary: TerminalSummary) -> TerminalSessionResponse {
    TerminalSessionResponse {
        websocket_url: operator_ws_path(&summary.terminal_id),
        terminal_id: summary.terminal_id,
        agent_id: summary.agent_id,
        created_at_unix: summary.created_at_unix,
        expires_at_unix: summary.expires_at_unix,
        agent_attached: summary.agent_attached,
        operator_attached: summary.operator_attached,
        attachment_token: None,
    }
 }
 fn agent_relay_frame(message: Message) -> Result<Option<TerminalRelayFrame>, &'static str> {
    match message {
        Message::Binary(bytes) => Ok(Some(TerminalRelayFrame::Binary(bytes.to_vec()))),
        Message::Text(text) => {
            let control: TerminalControl =
                serde_json::from_str(&text).map_err(|_| "terminal_control_invalid")?;
            if !matches!(
                control,
                TerminalControl::Ready
                    | TerminalControl::Exited { .. }
                    | TerminalControl::Error { .. }
                    | TerminalControl::Close
            ) {
                return Err("terminal_control_direction_invalid");
            }
            Ok(Some(TerminalRelayFrame::Text(
                serde_json::to_string(&control).map_err(|_| "terminal_control_invalid")?,
            )))
        }
        Message::Ping(_) | Message::Pong(_) => Ok(None),
        Message::Close(_) => Ok(Some(TerminalRelayFrame::Close)),
    }
 }
 fn operator_relay_frame(message: Message) -> Result<Option<TerminalRelayFrame>, &'static str> {
    match message {
        Message::Binary(bytes) => Ok(Some(TerminalRelayFrame::Binary(bytes.to_vec()))),
        Message::Text(text) => {
            let control: TerminalControl =
                serde_json::from_str(&text).map_err(|_| "terminal_control_invalid")?;
            if !matches!(
                control,
                TerminalControl::Resize { .. } | TerminalControl::Close
            ) {
                return Err("terminal_control_direction_invalid");
            }
            if let TerminalControl::Resize { rows, cols } = control {
                validate_size(rows, cols).map_err(|_| "terminal_size_invalid")?;
            }
            Ok(Some(TerminalRelayFrame::Text(
                serde_json::to_string(&control).map_err(|_| "terminal_control_invalid")?,
            )))
        }
        Message::Ping(_) | Message::Pong(_) => Ok(None),
        Message::Close(_) => Ok(None),
    }
 }
 async fn receive_text_handshake(socket: &mut WebSocket) -> Result<String, &'static str> {
    match tokio::time::timeout(TERMINAL_ATTACH_TIMEOUT, socket.recv()).await {
        Ok(Some(Ok(Message::Text(text)))) => Ok(text.to_string()),
        Ok(_) => Err("terminal_handshake_required"),
        Err(_) => Err("terminal_handshake_timeout"),
    }
 }
 async fn close_socket(socket: &mut WebSocket, code: &str) {
    let control = TerminalControl::Error {
        code: code.into(),
        message: code.replace('_', " "),
    };
    if let Ok(json) = serde_json::to_string(&control) {
        let _ = socket.send(Message::Text(json.into())).await;
    }
    let _ = socket.send(Message::Close(None)).await;
 }
 async fn send_relay_frame<S>(write: &mut S, frame: TerminalRelayFrame) -> Result<(), axum::Error>
 where
    S: futures_util::Sink<Message, Error = axum::Error> + Unpin,
 {
    let message = match frame {
        TerminalRelayFrame::Binary(bytes) => Message::Binary(bytes.into()),
        TerminalRelayFrame::Text(text) => Message::Text(text.into()),
        TerminalRelayFrame::Close => Message::Close(None),
    };
    write.send(message).await
 }
 #[derive(Clone, Copy)]
 enum TerminalCloseReason {
    HttpDelete,
    BrowserClose,
    AbsoluteTimeout,
 }
 impl TerminalCloseReason {
    fn as_str(self) -> &'static str {
        match self {
            Self::HttpDelete => "http_delete",
            Self::BrowserClose => "browser_close",
            Self::AbsoluteTimeout => "absolute_timeout",
        }
    }
 }
 /// Removes and audits a terminal as one logical operation. Only the caller
 /// that actually removes the session records the close, keeping retries and
 /// simultaneous timeout/operator closes from producing duplicate events.
 async fn close_registered_terminal(
    state: &AppState,
    terminal_id: &str,
    reason: TerminalCloseReason,
 ) -> Option<String> {
    let agent_id = state.terminals.remove(terminal_id).await?;
    if let Some(session) = state.sessions.read().await.get(&agent_id) {
        let terminal_id = TerminalId::new(terminal_id.to_string()).ok()?;
        let _ = session
            .tx
            .send(SessionEvent::Message(ServerMessage::CloseTerminal {
                terminal_id,
            }));
    }
    append_terminal_audit(
        state,
        &agent_id,
        terminal_id,
        TerminalAudit {
            actor_type: "admin_api",
            event_type: "terminal_close",
            outcome: "ok",
            message: "terminal session closed",
            metadata: serde_json::json!({ "reason": reason.as_str() }),
        },
    )
    .await;
    Some(agent_id)
 }
 fn spawn_session_timeout(
    state: AppState,
    terminal_id: TerminalId,
    agent_id: String,
    session_ttl_seconds: u64,
 ) {
    if session_ttl_seconds == 0 {
        return;
    }
    tokio::spawn(async move {
        tokio::time::sleep(Duration::from_secs(session_ttl_seconds)).await;
        if close_registered_terminal(
            &state,
            terminal_id.as_str(),
            TerminalCloseReason::AbsoluteTimeout,
        )
        .await
        .is_some()
        {
            info!(terminal_id = %terminal_id, agent_id, "terminal absolute timeout reached");
        }
    });
 }
 struct TerminalAudit<'a> {
    actor_type: &'a str,
    event_type: &'a str,
    outcome: &'a str,
    message: &'a str,
    metadata: serde_json::Value,
 }
 async fn audit_agent_control_frame(
    state: &AppState,
    agent_id: &str,
    terminal_id: &str,
    frame: &TerminalRelayFrame,
 ) {
    let TerminalRelayFrame::Text(text) = frame else {
        return;
    };
    let Ok(control) = serde_json::from_str::<TerminalControl>(text) else {
        return;
    };
    let audit = match control {
        TerminalControl::Ready => TerminalAudit {
            actor_type: "agent",
            event_type: "terminal_ready",
            outcome: "ok",
            message: "terminal PTY ready",
            metadata: serde_json::json!({}),
        },
        TerminalControl::Exited { exit_code } => TerminalAudit {
            actor_type: "agent",
            event_type: "terminal_exit",
            outcome: "exited",
            message: "terminal process exited",
            metadata: serde_json::json!({ "exit_code": exit_code }),
        },
        TerminalControl::Error { code, .. } => TerminalAudit {
            actor_type: "agent",
            event_type: "terminal_error",
            outcome: "error",
            message: "terminal worker reported an error",
            metadata: serde_json::json!({ "code": code }),
        },
        _ => return,
    };
    append_terminal_audit(state, agent_id, terminal_id, audit).await;
 }
 async fn append_terminal_audit(
    state: &AppState,
    agent_id: &str,
    terminal_id: &str,
    audit: TerminalAudit<'_>,
 ) {
    if let Err(err) = state
        .store
        .append_audit_event(AuditEventInput {
            actor_type: audit.actor_type.into(),
            actor_id: None,
            agent_id: Some(agent_id.to_string()),
            request_id: Some(terminal_id.to_string()),
            event_type: audit.event_type.into(),
            outcome: audit.outcome.into(),
            latency_ms: None,
            message: audit.message.into(),
            metadata: audit.metadata,
        })
        .await
    {
        warn!(terminal_id, event_type = audit.event_type, error = %err, "failed to append terminal audit event");
    }
 }
 fn validate_size(rows: u16, cols: u16) -> Result<(), ApiError> {
    if !(1..=300).contains(&rows) || !(1..=500).contains(&cols) {
        return Err(ApiError::new(
            StatusCode::BAD_REQUEST,
            "terminal_size_invalid",
            "terminal rows must be 1..=300 and columns must be 1..=500",
        ));
    }
    Ok(())
 }
 fn registry_error(code: &'static str) -> ApiError {
    let status = match code {
        "terminal_not_found" => StatusCode::NOT_FOUND,
        "terminal_operator_id_invalid" => StatusCode::BAD_REQUEST,
        "terminal_relay_token_invalid"
        | "terminal_attachment_token_invalid"
        | "terminal_operator_mismatch" => StatusCode::UNAUTHORIZED,
        _ => StatusCode::CONFLICT,
    };
    ApiError::new(status, code, code.replace('_', " "))
 }
 fn terminal_not_found(terminal_id: &str) -> ApiError {
    ApiError::new(
        StatusCode::NOT_FOUND,
        "terminal_not_found",
        format!("terminal session {terminal_id} was not found"),
    )
 }
 fn operator_ws_path(terminal_id: &str) -> String {
    format!("/api/v1/control/terminals/{terminal_id}/ws")
 }
 const fn default_rows() -> u16 {
    24
 }
 const fn default_cols() -> u16 {
    80
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    #[test]
    fn terminal_control_direction_is_enforced() {
        let resize = serde_json::to_string(&TerminalControl::Resize { rows: 24, cols: 80 })
            .expect("resize json");
        assert!(operator_relay_frame(Message::Text(resize.into())).is_ok());
        let ready = serde_json::to_string(&TerminalControl::Ready).expect("ready json");
        assert!(operator_relay_frame(Message::Text(ready.into())).is_err());
        let snapshot = serde_json::to_string(&TerminalControl::Snapshot).expect("snapshot json");
        assert!(operator_relay_frame(Message::Text(snapshot.into())).is_err());
    }
 }
@@ -4,7 +4,7 @@ use anyhow::{Context, Result};
 use crate::cli::{InitConfigArgs, ServeArgs};
 use crate::config::resolve::{load_file_config, normalize_public_url, resolve_path};
-use crate::config::types::{WritableConfig, WritableTelemetry};
+use crate::config::types::{DEFAULT_CONFIG, WritableConfig, WritableTelemetry};
 pub fn write_init_config(args: &InitConfigArgs) -> Result<Option<PathBuf>> {
    if args.stdout && args.config_file.is_some() {
@@ -30,6 +30,7 @@ pub fn write_init_config(args: &InitConfigArgs) -> Result<Option<PathBuf>> {
        Default::default()
    };
    let base_telemetry = base.telemetry.unwrap_or_default();
    let defaults = &*DEFAULT_CONFIG;
    let bind = match args.bind {
        Some(bind) => bind,
@@ -43,7 +44,8 @@ pub fn write_init_config(args: &InitConfigArgs) -> Result<Option<PathBuf>> {
                        .unwrap_or_else(|| "<defaults>".to_string())
                )
            })?,
-            None => "0.0.0.0:8080"
+            None => defaults
                .bind
                .parse()
                .expect("static default bind should parse"),
        },
@@ -52,37 +54,38 @@ pub fn write_init_config(args: &InitConfigArgs) -> Result<Option<PathBuf>> {
        args.public_url
            .as_deref()
            .or(base.public_url.as_deref())
-            .unwrap_or("http://127.0.0.1:8080"),
+            .unwrap_or(&defaults.public_url),
    );
    let data_dir = args
        .data_dir
        .clone()
        .or(base.data_dir)
-        .unwrap_or_else(|| PathBuf::from(crate::cli::DEFAULT_DATA_DIR));
+        .unwrap_or_else(|| defaults.data_dir.clone());
    let state_file_raw = args
        .state_file
        .clone()
        .or(base.state_file)
-        .unwrap_or_else(|| PathBuf::from("state.sqlite3"));
+        .unwrap_or_else(|| defaults.state_file.clone());
-    let state_file = resolve_path(&data_dir, state_file_raw);
+    let state_file = path_for_rendered_config(&data_dir, state_file_raw);
    let pid_file_raw = args
        .pid_file
        .clone()
        .or(base.pid_file)
-        .unwrap_or_else(|| PathBuf::from("wakey-control-plane.pid"));
+        .unwrap_or_else(|| defaults.pid_file.clone());
-    let pid_file = resolve_path(&data_dir, pid_file_raw);
+    let pid_file = path_for_rendered_config(&data_dir, pid_file_raw);
    let ui_dist_dir = args
        .ui_dist_dir
        .clone()
        .or(base.ui_dist_dir)
-        .unwrap_or_else(|| PathBuf::from("ui/dist"));
+        .unwrap_or_else(|| defaults.ui_dist_dir.clone());
    let bootstrap_enroll_tokens = if args.bootstrap_enroll_tokens.is_empty() {
-        base.bootstrap_enroll_tokens.unwrap_or_default()
+        base.bootstrap_enroll_tokens
            .unwrap_or_else(|| defaults.bootstrap_enroll_tokens.clone())
    } else {
        args.bootstrap_enroll_tokens.clone()
    };
@@ -95,17 +98,17 @@ pub fn write_init_config(args: &InitConfigArgs) -> Result<Option<PathBuf>> {
        command_timeout_ms: args
            .command_timeout_ms
            .or(base.command_timeout_ms)
-            .unwrap_or(30_000)
+            .unwrap_or(defaults.command_timeout_ms)
            .max(1),
        enroll_token_ttl_seconds: args
            .enroll_token_ttl_seconds
            .or(base.enroll_token_ttl_seconds)
-            .unwrap_or(86_400)
+            .unwrap_or(defaults.enroll_token_ttl_seconds)
            .max(1),
        observation_retention_seconds: args
            .observation_retention_seconds
            .or(base.observation_retention_seconds)
-            .unwrap_or(2_592_000),
+            .unwrap_or(defaults.observation_retention_seconds),
        pid_file,
        ui_dist_dir,
        bootstrap_enroll_tokens,
@@ -113,16 +116,17 @@ pub fn write_init_config(args: &InitConfigArgs) -> Result<Option<PathBuf>> {
            otlp_endpoint: args
                .telemetry_otlp_endpoint
                .clone()
-                .or(base_telemetry.otlp_endpoint),
+                .or(base_telemetry.otlp_endpoint)
                .or_else(|| defaults.telemetry.otlp_endpoint.clone()),
            service_name: args
                .telemetry_service_name
                .clone()
                .or(base_telemetry.service_name)
-                .unwrap_or_else(|| "wakey-control-plane".to_string()),
+                .unwrap_or_else(|| defaults.telemetry.service_name.clone()),
            json_logs: args
                .telemetry_json_logs
                .or(base_telemetry.json_logs)
-                .unwrap_or(false),
+                .unwrap_or(defaults.telemetry.json_logs),
        },
    };
@@ -143,6 +147,18 @@ pub fn write_init_config(args: &InitConfigArgs) -> Result<Option<PathBuf>> {
    Ok(None)
 }
 /// Keep relative paths relative when the rendered config's `data_dir` is also
 /// relative. The daemon resolves relative paths under `data_dir`; embedding
 /// that directory into another relative path here would make it get joined a
 /// second time when the generated config is loaded.
 fn path_for_rendered_config(data_dir: &std::path::Path, candidate: PathBuf) -> PathBuf {
    if data_dir.is_relative() && candidate.is_relative() {
        candidate
    } else {
        resolve_path(data_dir, candidate)
    }
 }
 pub fn bootstrap_config_if_missing(args: &ServeArgs) -> Result<bool> {
    if args.config_file.exists() {
        return Ok(false);
@@ -176,6 +192,7 @@ pub fn bootstrap_config_if_missing(args: &ServeArgs) -> Result<bool> {
 mod tests {
    use super::write_init_config;
    use crate::cli::InitConfigArgs;
    use crate::config::types::DEFAULT_CONFIG;
    fn temp_test_dir(name: &str) -> std::path::PathBuf {
        std::env::temp_dir().join(format!(
@@ -251,4 +268,98 @@ json_logs = true
        let _ = std::fs::remove_dir_all(&dir);
    }
    #[test]
    fn init_config_renders_shared_default_template() {
        let dir = temp_test_dir("defaults");
        let _ = std::fs::remove_dir_all(&dir);
        std::fs::create_dir_all(&dir).expect("create temp dir");
        let out = dir.join("out.toml");
        write_init_config(&InitConfigArgs {
            config_file: Some(out.clone()),
            from_config: None,
            stdout: false,
            data_dir: None,
            bind: None,
            public_url: None,
            state_file: None,
            pid_file: None,
            ui_dist_dir: None,
            command_timeout_ms: None,
            enroll_token_ttl_seconds: None,
            observation_retention_seconds: None,
            bootstrap_enroll_tokens: Vec::new(),
            telemetry_otlp_endpoint: None,
            telemetry_service_name: None,
            telemetry_json_logs: None,
            force: false,
        })
        .expect("write default config");
        let rendered = std::fs::read_to_string(&out).expect("read default config");
        let parsed: toml::Value = toml::from_str(&rendered).expect("parse default config");
        let defaults = &*DEFAULT_CONFIG;
        assert_eq!(
            parsed["state_file"].as_str(),
            defaults.data_dir.join(&defaults.state_file).to_str()
        );
        assert_eq!(
            parsed["command_timeout_ms"].as_integer(),
            Some(defaults.command_timeout_ms as i64)
        );
        assert_eq!(
            parsed["telemetry"]["service_name"].as_str(),
            Some(defaults.telemetry.service_name.as_str())
        );
        let _ = std::fs::remove_dir_all(&dir);
    }
    #[test]
    fn init_config_preserves_relative_paths_for_relative_data_dir() {
        let dir = temp_test_dir("relative-data-dir");
        let _ = std::fs::remove_dir_all(&dir);
        std::fs::create_dir_all(&dir).expect("create temp dir");
        let base = dir.join("base.toml");
        let out = dir.join("out.toml");
        std::fs::write(
            &base,
            r#"
 data_dir = "test-ddir/wakey-control-plane"
 state_file = "state.sqlite3"
 pid_file = "wakey-control-plane.pid"
 "#,
        )
        .expect("write base config");
        write_init_config(&InitConfigArgs {
            config_file: Some(out.clone()),
            from_config: Some(base),
            stdout: false,
            data_dir: None,
            bind: None,
            public_url: None,
            state_file: None,
            pid_file: None,
            ui_dist_dir: None,
            command_timeout_ms: None,
            enroll_token_ttl_seconds: None,
            observation_retention_seconds: None,
            bootstrap_enroll_tokens: Vec::new(),
            telemetry_otlp_endpoint: None,
            telemetry_service_name: None,
            telemetry_json_logs: None,
            force: false,
        })
        .expect("write derived config");
        let parsed: toml::Value =
            toml::from_str(&std::fs::read_to_string(&out).expect("read derived config"))
                .expect("parse derived config");
        assert_eq!(parsed["state_file"].as_str(), Some("state.sqlite3"));
        assert_eq!(parsed["pid_file"].as_str(), Some("wakey-control-plane.pid"));
        let _ = std::fs::remove_dir_all(&dir);
    }
 }
@@ -9,19 +9,20 @@ use crate::cli::{
    RevokeEnrollTokenArgs, ServeArgs, StateStatsArgs,
 };
 use crate::config::types::{
-    DaemonConfig, FileConfig, FileTelemetryConfig, IssueTokenSettings, StateAccessSettings,
+    DEFAULT_CONFIG, DaemonConfig, FileConfig, FileTelemetryConfig, IssueTokenSettings,
-    TelemetryConfig,
+    StateAccessSettings, TelemetryConfig,
 };
 impl DaemonConfig {
    pub fn from_serve_args(args: &ServeArgs) -> Result<Self> {
        let file = load_file_config(&args.config_file)?;
        let defaults = &*DEFAULT_CONFIG;
        let data_dir = args
            .data_dir
            .clone()
            .or(file.data_dir.clone())
-            .unwrap_or_else(|| PathBuf::from(crate::cli::DEFAULT_DATA_DIR));
+            .unwrap_or_else(|| defaults.data_dir.clone());
        let bind = match args.bind {
            Some(bind) => bind,
@@ -32,7 +33,8 @@ impl DaemonConfig {
                        args.config_file.display()
                    )
                })?,
-                None => "0.0.0.0:8080"
+                None => defaults
                    .bind
                    .parse()
                    .expect("static default bind should parse"),
            },
@@ -42,34 +44,34 @@ impl DaemonConfig {
            args.public_url
                .as_deref()
                .or(file.public_url.as_deref())
-                .unwrap_or("http://127.0.0.1:8080"),
+                .unwrap_or(&defaults.public_url),
        );
        let state_file_raw = args
            .state_file
            .clone()
            .or(file.state_file)
-            .unwrap_or_else(|| PathBuf::from("state.sqlite3"));
+            .unwrap_or_else(|| defaults.state_file.clone());
        let state_file = resolve_path(&data_dir, state_file_raw);
        let command_timeout = Duration::from_millis(
            args.command_timeout_ms
                .or(file.command_timeout_ms)
-                .unwrap_or(30_000)
+                .unwrap_or(defaults.command_timeout_ms)
                .max(1),
        );
        let enroll_token_ttl = Duration::from_secs(
            args.enroll_token_ttl_seconds
                .or(file.enroll_token_ttl_seconds)
-                .unwrap_or(86_400)
+                .unwrap_or(defaults.enroll_token_ttl_seconds)
                .max(1),
        );
        let observation_retention = Duration::from_secs(
            args.observation_retention_seconds
                .or(file.observation_retention_seconds)
-                .unwrap_or(2_592_000)
+                .unwrap_or(defaults.observation_retention_seconds)
                .max(1),
        );
@@ -77,17 +79,18 @@ impl DaemonConfig {
            .pid_file
            .clone()
            .or(file.pid_file)
-            .unwrap_or_else(|| PathBuf::from("wakey-control-plane.pid"));
+            .unwrap_or_else(|| defaults.pid_file.clone());
        let pid_file = resolve_path(&data_dir, pid_file_raw);
        let ui_dist_dir = args
            .ui_dist_dir
            .clone()
            .or(file.ui_dist_dir)
-            .unwrap_or_else(|| PathBuf::from("ui/dist"));
+            .unwrap_or_else(|| defaults.ui_dist_dir.clone());
        let bootstrap_enroll_tokens = if args.bootstrap_enroll_tokens.is_empty() {
-            file.bootstrap_enroll_tokens.unwrap_or_default()
+            file.bootstrap_enroll_tokens
                .unwrap_or_else(|| defaults.bootstrap_enroll_tokens.clone())
        } else {
            args.bootstrap_enroll_tokens.clone()
        };
@@ -131,6 +134,7 @@ pub fn resolve_path(data_dir: &Path, candidate: PathBuf) -> PathBuf {
 pub fn resolve_issue_token_settings(args: &IssueEnrollTokenArgs) -> Result<IssueTokenSettings> {
    let file = load_file_config(&args.config_file)?;
    let defaults = &*DEFAULT_CONFIG;
    let state = resolve_state_access(
        &args.config_file,
        args.data_dir.clone(),
@@ -142,7 +146,7 @@ pub fn resolve_issue_token_settings(args: &IssueEnrollTokenArgs) -> Result<Issue
    let ttl = Duration::from_secs(
        args.ttl_seconds
            .or(file.enroll_token_ttl_seconds)
-            .unwrap_or(86_400)
+            .unwrap_or(defaults.enroll_token_ttl_seconds)
            .max(1),
    );
@@ -254,16 +258,17 @@ fn resolve_state_access(
    mode: &AdminTargetArgs,
 ) -> Result<StateAccessSettings> {
    let file = load_file_config(config_file)?;
    let defaults = &*DEFAULT_CONFIG;
    let data_dir = cli_data_dir
        .or(file.data_dir)
-        .unwrap_or_else(|| PathBuf::from(crate::cli::DEFAULT_DATA_DIR));
+        .unwrap_or_else(|| defaults.data_dir.clone());
    let state_file = resolve_path(
        &data_dir,
        cli_state_file
            .or(file.state_file)
-            .unwrap_or_else(|| PathBuf::from("state.sqlite3")),
+            .unwrap_or_else(|| defaults.state_file.clone()),
    );
    let resolved_public_url = cli_public_url
@@ -280,7 +285,9 @@ fn resolve_state_access(
 #[cfg(test)]
 mod tests {
-    use super::{normalize_public_url, resolve_path};
+    use super::{DaemonConfig, normalize_public_url, resolve_path};
    use crate::cli::ServeArgs;
    use crate::config::types::DEFAULT_CONFIG;
    use std::path::Path;
    use std::path::PathBuf;
@@ -303,4 +310,43 @@ mod tests {
            PathBuf::from("/var/lib/wakey-control-plane/state.sqlite3")
        );
    }
    #[test]
    fn daemon_config_uses_shared_default_template() {
        let config_file = std::env::temp_dir().join(format!(
            "wakey-cc-missing-config-{}.toml",
            std::process::id()
        ));
        let _ = std::fs::remove_file(&config_file);
        let resolved = DaemonConfig::from_serve_args(&ServeArgs {
            data_dir: None,
            bind: None,
            public_url: None,
            state_file: None,
            bootstrap_enroll_tokens: Vec::new(),
            command_timeout_ms: None,
            enroll_token_ttl_seconds: None,
            observation_retention_seconds: None,
            pid_file: None,
            ui_dist_dir: None,
            config_file,
            bootstrap_config: false,
        })
        .expect("resolve default config");
        let defaults = &*DEFAULT_CONFIG;
        assert_eq!(resolved.data_dir, defaults.data_dir);
        assert_eq!(
            resolved.state_file,
            defaults.data_dir.join(&defaults.state_file)
        );
        assert_eq!(
            resolved.command_timeout,
            std::time::Duration::from_millis(defaults.command_timeout_ms)
        );
        assert_eq!(
            resolved.telemetry.service_name,
            defaults.telemetry.service_name
        );
    }
 }
@@ -1,5 +1,6 @@
 use std::net::SocketAddr;
 use std::path::PathBuf;
 use std::sync::LazyLock;
 use std::time::Duration;
 use serde::{Deserialize, Serialize};
@@ -29,10 +30,11 @@ pub struct TelemetryConfig {
 impl Default for TelemetryConfig {
    fn default() -> Self {
        let defaults = &DEFAULT_CONFIG.telemetry;
        Self {
-            otlp_endpoint: None,
+            otlp_endpoint: defaults.otlp_endpoint.clone(),
-            service_name: "wakey-control-plane".to_string(),
+            service_name: defaults.service_name.clone(),
-            json_logs: false,
+            json_logs: defaults.json_logs,
        }
    }
 }
@@ -60,7 +62,7 @@ pub(crate) struct FileTelemetryConfig {
    pub(crate) json_logs: Option<bool>,
 }
-#[derive(Debug, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 pub(crate) struct WritableConfig {
    pub(crate) data_dir: PathBuf,
    pub(crate) bind: String,
@@ -76,7 +78,7 @@ pub(crate) struct WritableConfig {
    pub(crate) telemetry: WritableTelemetry,
 }
-#[derive(Debug, Serialize)]
+#[derive(Debug, Clone, Serialize)]
 pub(crate) struct WritableTelemetry {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub(crate) otlp_endpoint: Option<String>,
@@ -84,6 +86,24 @@ pub(crate) struct WritableTelemetry {
    pub(crate) json_logs: bool,
 }
 pub(crate) static DEFAULT_CONFIG: LazyLock<WritableConfig> = LazyLock::new(|| WritableConfig {
    data_dir: crate::cli::DEFAULT_DATA_DIR.into(),
    bind: "0.0.0.0:8080".to_string(),
    public_url: "http://127.0.0.1:8080".to_string(),
    state_file: "state.sqlite3".into(),
    command_timeout_ms: 30_000,
    enroll_token_ttl_seconds: 86_400,
    observation_retention_seconds: 2_592_000,
    pid_file: "wakey-control-plane.pid".into(),
    ui_dist_dir: "ui/dist".into(),
    bootstrap_enroll_tokens: Vec::new(),
    telemetry: WritableTelemetry {
        otlp_endpoint: None,
        service_name: "wakey-control-plane".to_string(),
        json_logs: false,
    },
 });
 pub struct IssueTokenSettings {
    pub data_dir: PathBuf,
    pub state_file: PathBuf,
@@ -16,7 +16,7 @@ use tower_http::services::ServeFile;
 use tracing::info;
 #[cfg(unix)]
 use tracing::warn;
-use wakey_agent::protocol::{ErrorPayload, ServerMessage};
+use wakey_agent::protocol::{AgentCapability, AgentCapabilityOptions, ErrorPayload, ServerMessage};
 use crate::api;
 use crate::config;
@@ -25,6 +25,7 @@ use crate::ws;
 mod admin;
 mod process;
 pub mod terminals;
 pub use admin::revoke_agent;
 pub use admin::{
    issue_enroll_token, list_enroll_tokens, migrate_sqlite_state, revoke_enroll_token, state_stats,
@@ -41,12 +42,15 @@ pub struct AppState {
    pub public_url: String,
    pub command_timeout: Duration,
    pub enroll_token_ttl: Duration,
    pub terminals: terminals::TerminalRegistry,
 }
 #[derive(Clone)]
 pub struct AgentSession {
    pub connection_id: String,
    pub tx: mpsc::UnboundedSender<SessionEvent>,
    pub capabilities: Vec<AgentCapability>,
    pub capability_options: AgentCapabilityOptions,
 }
 #[derive(Clone)]
 pub enum SessionEvent {
@@ -67,11 +71,15 @@ fn public_api_routes(ui_dist_dir: std::path::PathBuf) -> Router<AppState> {
        .route("/", get(|| async { Redirect::temporary("/ui/") })) // same as caddyfile
        .nest_service(
            "/ui/",
-            get_service(ServeDir::new(ui_dist_dir).not_found_service(ServeFile::new(index_file))),
+            get_service(ServeDir::new(ui_dist_dir).fallback(ServeFile::new(index_file))),
        )
        .route("/healthz", get(api::healthz))
        .route("/api/v1/agents/enroll", post(api::enroll))
        .route("/api/v1/agent/ws", get(ws::agent_ws))
        .route(
            "/api/v1/agent/terminals/{terminal_id}/ws",
            get(api::agent_terminal_ws),
        )
 }
 fn control_api_routes() -> Router<AppState> {
@@ -104,7 +112,7 @@ fn control_api_routes() -> Router<AppState> {
        )
        .route(
            "/api/v1/control/devices/{device_id}",
-            axum::routing::delete(api::forget_known_device),
+            get(api::get_known_device).delete(api::forget_known_device),
        )
        .route(
            "/api/v1/control/devices/{device_id}/merge",
@@ -135,6 +143,22 @@ fn control_api_routes() -> Router<AppState> {
            "/api/v1/control/agents/{agent_id}/command",
            post(api::run_command),
        )
        .route(
            "/api/v1/control/terminals",
            get(api::list_terminals).post(api::create_terminal),
        )
        .route(
            "/api/v1/control/terminals/{terminal_id}",
            get(api::get_terminal).delete(api::close_terminal),
        )
        .route(
            "/api/v1/control/terminals/{terminal_id}/attach",
            post(api::attach_terminal),
        )
        .route(
            "/api/v1/control/terminals/{terminal_id}/ws",
            get(api::operator_terminal_ws),
        )
 }
 /// Starts the control-plane HTTP and websocket surfaces and manages daemon lifecycle hooks.
@@ -157,6 +181,7 @@ pub async fn serve(daemon: config::DaemonConfig) -> Result<()> {
        public_url: daemon.public_url.clone(),
        command_timeout: daemon.command_timeout,
        enroll_token_ttl: daemon.enroll_token_ttl,
        terminals: terminals::TerminalRegistry::new(),
    };
    // Keep route classes explicit so edge policy can map directly:
@@ -0,0 +1,993 @@
 use std::collections::{HashMap, VecDeque};
 use std::sync::Arc;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use tokio::sync::{Mutex, mpsc};
 use uuid::Uuid;
 use wakey_agent::protocol::{AgentTerminalSession, TerminalId};
 pub const TERMINAL_RELAY_QUEUE: usize = 32;
 pub const TERMINAL_MAX_FRAME_BYTES: usize = 64 * 1024;
 pub const TERMINAL_PENDING_AGENT_BYTES: usize = 256 * 1024;
 pub const TERMINAL_ATTACH_TIMEOUT: Duration = Duration::from_secs(10);
 const TERMINAL_TOMBSTONE_TTL: Duration = Duration::from_secs(5 * 60);
 const TERMINAL_MAX_TOMBSTONES: usize = 1024;
 #[derive(Clone, Debug)]
 pub enum TerminalRelayFrame {
    Binary(Vec<u8>),
    Text(String),
    Close,
 }
 #[derive(Clone)]
 pub struct TerminalRegistry {
    inner: Arc<Mutex<HashMap<String, TerminalSession>>>,
    closed: Arc<Mutex<HashMap<String, Instant>>>,
 }
 struct TerminalSession {
    agent_id: String,
    created_at_unix: u64,
    expiry: TerminalExpiry,
    agent_confirmed: bool,
    relay_token: Option<String>,
    attachment_token: Option<String>,
    attachment_operator_id: Option<String>,
    agent_tx: Option<mpsc::Sender<TerminalRelayFrame>>,
    pending_agent: VecDeque<TerminalRelayFrame>,
    pending_agent_bytes: usize,
    operator_tx: Option<mpsc::Sender<TerminalRelayFrame>>,
    operator_id: Option<String>,
    operator_connection_id: Option<String>,
    operator_detached_at: Option<Instant>,
 }
 pub struct CreatedTerminal {
    pub terminal_id: String,
    pub relay_token: String,
    pub attachment_token: String,
    pub created_at_unix: u64,
    pub expires_at_unix: Option<u64>,
 }
 #[derive(Clone, Debug)]
 pub struct TerminalSummary {
    pub terminal_id: String,
    pub agent_id: String,
    pub created_at_unix: u64,
    pub expires_at_unix: Option<u64>,
    pub agent_attached: bool,
    pub operator_attached: bool,
 }
 impl Default for TerminalRegistry {
    fn default() -> Self {
        Self::new()
    }
 }
 impl TerminalRegistry {
    pub fn new() -> Self {
        Self {
            inner: Arc::new(Mutex::new(HashMap::new())),
            closed: Arc::new(Mutex::new(HashMap::new())),
        }
    }
    #[cfg(test)]
    async fn create(&self, agent_id: String) -> Result<CreatedTerminal, &'static str> {
        self.create_with_limits(
            agent_id,
            wakey_agent::protocol::DEFAULT_TERMINAL_MAX_SESSIONS,
            wakey_agent::protocol::DEFAULT_TERMINAL_SESSION_TTL_SECONDS,
        )
        .await
    }
    /// Creates a session using the limit advertised by the connected agent.
    /// The caller snapshots the limit with the agent connection so UI hints and
    /// server-side enforcement use the same value.
    pub async fn create_with_limits(
        &self,
        agent_id: String,
        max_sessions: usize,
        session_ttl_seconds: u64,
    ) -> Result<CreatedTerminal, &'static str> {
        let mut sessions = self.inner.lock().await;
        prune_expired_sessions(&mut sessions);
        if sessions
            .values()
            .filter(|session| session.agent_id == agent_id)
            .count()
            >= max_sessions.max(1)
        {
            return Err("agent_terminal_limit_reached");
        }
        let terminal_id = Uuid::new_v4().to_string();
        let relay_token = new_token();
        let attachment_token = new_token();
        let created_at_unix = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs();
        let expiry = expiry_for_created_at(created_at_unix, session_ttl_seconds)
            .ok_or("terminal_ttl_invalid")?;
        sessions.insert(
            terminal_id.clone(),
            TerminalSession {
                agent_id,
                created_at_unix,
                expiry,
                agent_confirmed: false,
                relay_token: Some(relay_token.clone()),
                attachment_token: Some(attachment_token.clone()),
                attachment_operator_id: None,
                agent_tx: None,
                pending_agent: VecDeque::new(),
                pending_agent_bytes: 0,
                operator_tx: None,
                operator_id: None,
                operator_connection_id: None,
                operator_detached_at: None,
            },
        );
        Ok(CreatedTerminal {
            terminal_id,
            relay_token,
            attachment_token,
            created_at_unix,
            expires_at_unix: expiry.unix(),
        })
    }
    pub async fn remove(&self, terminal_id: &str) -> Option<String> {
        let session = self.inner.lock().await.remove(terminal_id)?;
        self.remember_closed(terminal_id).await;
        if let Some(tx) = session.agent_tx {
            let _ =
                tokio::time::timeout(Duration::from_secs(1), tx.send(TerminalRelayFrame::Close))
                    .await;
        }
        if let Some(tx) = session.operator_tx {
            let _ =
                tokio::time::timeout(Duration::from_secs(1), tx.send(TerminalRelayFrame::Close))
                    .await;
        }
        Some(session.agent_id)
    }
    /// Reports whether a session ID was recently removed. Tombstones make
    /// idempotent DELETE distinguishable from a completely unknown ID.
    pub async fn was_closed(&self, terminal_id: &str) -> bool {
        let mut closed = self.closed.lock().await;
        prune_tombstones(&mut closed);
        closed.contains_key(terminal_id)
    }
    async fn remember_closed(&self, terminal_id: &str) {
        let mut closed = self.closed.lock().await;
        prune_tombstones(&mut closed);
        closed.insert(terminal_id.to_string(), Instant::now());
        if closed.len() > TERMINAL_MAX_TOMBSTONES
            && let Some(oldest) = closed
                .iter()
                .min_by_key(|(_, closed_at)| **closed_at)
                .map(|(terminal_id, _)| terminal_id.clone())
        {
            closed.remove(&oldest);
        }
    }
    /// Rebuilds CC's volatile catalog from the PTYs still owned by an agent.
    /// Returned credentials tell those workers to establish fresh relay sockets.
    pub async fn reconcile_agent_sessions(
        &self,
        agent_id: &str,
        reported: &[AgentTerminalSession],
    ) -> Vec<(TerminalId, String)> {
        let reported_ids = reported
            .iter()
            .filter(|session| {
                expiry_for_created_at(session.created_at_unix, session.session_ttl_seconds)
                    .is_some()
            })
            .map(|session| session.terminal_id.as_str())
            .collect::<std::collections::HashSet<_>>();
        let stale_ids = {
            let mut sessions = self.inner.lock().await;
            prune_expired_sessions(&mut sessions);
            sessions
                .iter()
                .filter(|(terminal_id, session)| {
                    session.agent_id == agent_id
                        && session.agent_confirmed
                        && !reported_ids.contains(terminal_id.as_str())
                })
                .map(|(terminal_id, _)| terminal_id.clone())
                .collect::<Vec<_>>()
        };
        for terminal_id in stale_ids {
            self.remove(&terminal_id).await;
        }
        let mut credentials = Vec::new();
        let mut sessions = self.inner.lock().await;
        for reported_session in reported {
            let Some(expiry) = expiry_for_created_at(
                reported_session.created_at_unix,
                reported_session.session_ttl_seconds,
            ) else {
                continue;
            };
            let terminal_id = reported_session.terminal_id.as_str().to_string();
            let session = sessions
                .entry(terminal_id)
                .or_insert_with(|| TerminalSession {
                    agent_id: agent_id.to_string(),
                    created_at_unix: reported_session.created_at_unix,
                    expiry,
                    agent_confirmed: true,
                    relay_token: None,
                    attachment_token: None,
                    attachment_operator_id: None,
                    agent_tx: None,
                    pending_agent: VecDeque::new(),
                    pending_agent_bytes: 0,
                    operator_tx: None,
                    operator_id: None,
                    operator_connection_id: None,
                    operator_detached_at: Some(Instant::now()),
                });
            if session.agent_id != agent_id || session.agent_tx.is_some() {
                continue;
            }
            session.agent_confirmed = true;
            let token = new_token();
            session.relay_token = Some(token.clone());
            credentials.push((reported_session.terminal_id.clone(), token));
        }
        credentials
    }
    pub async fn detach_agent(&self, terminal_id: &str) -> Option<String> {
        let mut sessions = self.inner.lock().await;
        let session = sessions.get_mut(terminal_id)?;
        session.agent_tx = None;
        Some(session.agent_id.clone())
    }
    /// Issues a token while atomically handing this operator's attachment to
    /// the target. A different operator remains protected by the single-viewer
    /// rule, while a stale socket owned by this operator can be replaced.
    pub async fn issue_attachment_token_for_operator(
        &self,
        terminal_id: &str,
        operator_id: &str,
    ) -> Result<String, &'static str> {
        validate_operator_id(operator_id)?;
        let mut sessions = self.inner.lock().await;
        let target = active_session(&mut sessions, terminal_id)?;
        if target.operator_tx.is_some() && target.operator_id.as_deref() != Some(operator_id) {
            return Err("terminal_operator_already_attached");
        }
        detach_operator_sessions(&mut sessions, operator_id);
        let session = active_session(&mut sessions, terminal_id)?;
        let token = new_token();
        session.attachment_token = Some(token.clone());
        session.attachment_operator_id = Some(operator_id.to_string());
        Ok(token)
    }
    pub async fn attach_agent(
        &self,
        terminal_id: &str,
        agent_id: &str,
        relay_token: &str,
    ) -> Result<(mpsc::Receiver<TerminalRelayFrame>, Vec<TerminalRelayFrame>), &'static str> {
        let mut sessions = self.inner.lock().await;
        let session = active_session(&mut sessions, terminal_id)?;
        if session.agent_id != agent_id {
            return Err("terminal_agent_mismatch");
        }
        if session.agent_tx.is_some() {
            return Err("terminal_agent_already_attached");
        }
        if session.relay_token.as_deref() != Some(relay_token) {
            return Err("terminal_relay_token_invalid");
        }
        session.relay_token = None;
        session.agent_confirmed = true;
        let (tx, rx) = mpsc::channel(TERMINAL_RELAY_QUEUE);
        session.agent_tx = Some(tx);
        let pending = session.pending_agent.drain(..).collect();
        session.pending_agent_bytes = 0;
        Ok((rx, pending))
    }
    pub async fn attach_operator(
        &self,
        terminal_id: &str,
        attachment_token: &str,
        operator_id: &str,
    ) -> Result<mpsc::Receiver<TerminalRelayFrame>, &'static str> {
        validate_operator_id(operator_id)?;
        let mut sessions = self.inner.lock().await;
        let session = active_session(&mut sessions, terminal_id)?;
        if session.operator_tx.is_some() {
            return Err("terminal_operator_already_attached");
        }
        if session.attachment_token.as_deref() != Some(attachment_token) {
            return Err("terminal_attachment_token_invalid");
        }
        if session
            .attachment_operator_id
            .as_deref()
            .is_some_and(|expected| expected != operator_id)
        {
            return Err("terminal_operator_mismatch");
        }
        // Initial create tokens are not yet bound to an operator. Once the
        // WebSocket presents that token, it still atomically releases any
        // older session held by the same browser tab.
        detach_operator_sessions(&mut sessions, operator_id);
        let session = active_session(&mut sessions, terminal_id)?;
        session.attachment_token = None;
        session.attachment_operator_id = None;
        session.operator_detached_at = None;
        let (tx, rx) = mpsc::channel(TERMINAL_RELAY_QUEUE);
        session.operator_tx = Some(tx);
        session.operator_id = Some(operator_id.to_string());
        session.operator_connection_id = Some(attachment_token.to_string());
        Ok(rx)
    }
    pub async fn relay_to_agent(
        &self,
        terminal_id: &str,
        frame: TerminalRelayFrame,
    ) -> Result<(), &'static str> {
        // Select the attached transport or enqueue the frame while holding one
        // lock. Otherwise an agent can attach between those decisions and
        // leave input stranded in the pre-attachment queue.
        let tx = {
            let mut sessions = self.inner.lock().await;
            let session = active_session(&mut sessions, terminal_id)?;
            if let Some(tx) = session.agent_tx.clone() {
                tx
            } else {
                session.pending_agent_bytes += relay_frame_size(&frame);
                session.pending_agent.push_back(frame);
                while session.pending_agent_bytes > TERMINAL_PENDING_AGENT_BYTES {
                    if let Some(dropped) = session.pending_agent.pop_front() {
                        session.pending_agent_bytes -= relay_frame_size(&dropped);
                    } else {
                        break;
                    }
                }
                return Ok(());
            }
        };
        tx.send(frame)
            .await
            .map_err(|_| "terminal_agent_disconnected")
    }
    pub async fn relay_from_agent(
        &self,
        terminal_id: &str,
        frame: TerminalRelayFrame,
    ) -> Result<(), &'static str> {
        let operator_tx = {
            let mut sessions = self.inner.lock().await;
            let session = active_session(&mut sessions, terminal_id)?;
            session.operator_tx.clone()
        };
        if let Some(tx) = operator_tx {
            match tx.send(frame).await {
                Ok(()) => return Ok(()),
                Err(_) => {
                    // The browser task may not have marked itself detached yet.
                    // Detach its stale sender; the agent's parsed screen remains
                    // authoritative and will reconstruct the next attachment.
                    let mut sessions = self.inner.lock().await;
                    let session = active_session(&mut sessions, terminal_id)?;
                    if session
                        .operator_tx
                        .as_ref()
                        .is_some_and(|current| current.same_channel(&tx))
                    {
                        clear_operator_attachment(session);
                    }
                    return Ok(());
                }
            }
        }
        Ok(())
    }
    pub async fn reject(
        &self,
        terminal_id: &str,
        agent_id: &str,
        error_json: String,
    ) -> Result<(), &'static str> {
        let matches_agent = self
            .inner
            .lock()
            .await
            .get(terminal_id)
            .is_some_and(|session| session.agent_id == agent_id);
        if !matches_agent {
            return Err("terminal_agent_mismatch");
        }
        self.relay_from_agent(terminal_id, TerminalRelayFrame::Text(error_json))
            .await?;
        self.remove(terminal_id)
            .await
            .map(|_| ())
            .ok_or("terminal_not_found")
    }
    /// Detaches only the socket identified by this attachment token. Delayed
    /// cleanup from an older socket must not clear its replacement.
    pub async fn detach_operator(&self, terminal_id: &str, connection_id: &str) -> Option<Instant> {
        let mut sessions = self.inner.lock().await;
        let session = sessions.get_mut(terminal_id)?;
        if session.operator_connection_id.as_deref() != Some(connection_id) {
            return None;
        }
        let detached_at = Instant::now();
        clear_operator_attachment(session);
        Some(detached_at)
    }
    pub async fn summary(&self, terminal_id: &str) -> Option<TerminalSummary> {
        let mut sessions = self.inner.lock().await;
        prune_expired_sessions(&mut sessions);
        sessions
            .get(terminal_id)
            .map(|session| terminal_summary(terminal_id, session))
    }
    pub async fn summaries(&self) -> Vec<TerminalSummary> {
        let mut sessions = self.inner.lock().await;
        prune_expired_sessions(&mut sessions);
        let mut summaries = sessions
            .iter()
            .map(|(terminal_id, session)| terminal_summary(terminal_id, session))
            .collect::<Vec<_>>();
        summaries.sort_by_key(|session| std::cmp::Reverse(session.created_at_unix));
        summaries
    }
 }
 fn terminal_summary(terminal_id: &str, session: &TerminalSession) -> TerminalSummary {
    TerminalSummary {
        terminal_id: terminal_id.to_string(),
        agent_id: session.agent_id.clone(),
        created_at_unix: session.created_at_unix,
        expires_at_unix: session.expiry.unix(),
        agent_attached: session.agent_tx.is_some(),
        operator_attached: session.operator_tx.is_some(),
    }
 }
 fn active_session<'a>(
    sessions: &'a mut HashMap<String, TerminalSession>,
    terminal_id: &str,
 ) -> Result<&'a mut TerminalSession, &'static str> {
    if sessions
        .get(terminal_id)
        .is_some_and(|session| session.expiry.is_expired(Instant::now()))
    {
        sessions.remove(terminal_id);
        return Err("terminal_expired");
    }
    sessions.get_mut(terminal_id).ok_or("terminal_not_found")
 }
 fn validate_operator_id(operator_id: &str) -> Result<(), &'static str> {
    if operator_id.is_empty() || operator_id.len() > 128 {
        return Err("terminal_operator_id_invalid");
    }
    Ok(())
 }
 fn detach_operator_sessions(sessions: &mut HashMap<String, TerminalSession>, operator_id: &str) {
    for session in sessions.values_mut() {
        if session.operator_id.as_deref() == Some(operator_id) {
            clear_operator_attachment(session);
        }
    }
 }
 fn clear_operator_attachment(session: &mut TerminalSession) {
    session.operator_tx = None;
    session.operator_id = None;
    session.operator_connection_id = None;
    session.operator_detached_at = Some(Instant::now());
 }
 fn new_token() -> String {
    format!("{}{}", Uuid::new_v4().simple(), Uuid::new_v4().simple())
 }
 fn prune_tombstones(closed: &mut HashMap<String, Instant>) {
    closed.retain(|_, closed_at| closed_at.elapsed() < TERMINAL_TOMBSTONE_TTL);
 }
 fn prune_expired_sessions(sessions: &mut HashMap<String, TerminalSession>) {
    let now = Instant::now();
    sessions.retain(|_, session| !session.expiry.is_expired(now));
 }
 #[derive(Clone, Copy, Debug)]
 enum TerminalExpiry {
    Unlimited,
    Finite { deadline: Instant, unix: u64 },
 }
 impl TerminalExpiry {
    fn unix(self) -> Option<u64> {
        match self {
            Self::Unlimited => None,
            Self::Finite { unix, .. } => Some(unix),
        }
    }
    fn is_expired(self, now: Instant) -> bool {
        matches!(self, Self::Finite { deadline, .. } if deadline <= now)
    }
 }
 /// Converts the agent's creation-time policy into CC's monotonic deadline.
 /// `None` rejects expired or unrepresentable sessions; `Unlimited` is the
 /// explicit zero-TTL policy.
 fn expiry_for_created_at(created_at_unix: u64, session_ttl_seconds: u64) -> Option<TerminalExpiry> {
    if session_ttl_seconds == 0 {
        return Some(TerminalExpiry::Unlimited);
    }
    let expires_at_unix = created_at_unix.checked_add(session_ttl_seconds)?;
    let now_unix = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs();
    if expires_at_unix <= now_unix {
        return None;
    }
    let remaining = Duration::from_secs(expires_at_unix - now_unix);
    Some(TerminalExpiry::Finite {
        deadline: Instant::now().checked_add(remaining)?,
        unix: expires_at_unix,
    })
 }
 fn relay_frame_size(frame: &TerminalRelayFrame) -> usize {
    match frame {
        TerminalRelayFrame::Binary(bytes) => bytes.len(),
        TerminalRelayFrame::Text(text) => text.len(),
        TerminalRelayFrame::Close => 0,
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use wakey_agent::protocol::DEFAULT_TERMINAL_SESSION_TTL_SECONDS;
    const OPERATOR_A: &str = "browser-tab-a";
    const OPERATOR_B: &str = "browser-tab-b";
    #[tokio::test]
    async fn credentials_are_scoped_and_single_use() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        assert!(
            registry
                .attach_agent(&created.terminal_id, "other", &created.relay_token)
                .await
                .is_err()
        );
        let _ = registry
            .attach_agent(&created.terminal_id, "router", &created.relay_token)
            .await
            .expect("attach agent");
        assert_eq!(
            registry
                .attach_agent(&created.terminal_id, "router", &created.relay_token)
                .await
                .expect_err("relay token is single use"),
            "terminal_agent_already_attached"
        );
        registry
            .attach_operator(&created.terminal_id, &created.attachment_token, OPERATOR_A)
            .await
            .expect("attach operator");
        assert!(
            registry
                .attach_operator(&created.terminal_id, &created.attachment_token, OPERATOR_A,)
                .await
                .is_err()
        );
    }
    #[tokio::test]
    async fn detached_output_is_not_transcribed_by_control_plane() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        registry
            .relay_from_agent(
                &created.terminal_id,
                TerminalRelayFrame::Binary(b"not retained".to_vec()),
            )
            .await
            .expect("ignore detached output");
        let mut outbound = registry
            .attach_operator(&created.terminal_id, &created.attachment_token, OPERATOR_A)
            .await
            .expect("attach operator");
        assert!(outbound.try_recv().is_err());
    }
    #[tokio::test]
    async fn attached_output_is_delivered_live_only() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        let mut outbound = registry
            .attach_operator(&created.terminal_id, &created.attachment_token, OPERATOR_A)
            .await
            .expect("attach operator");
        let frame = TerminalRelayFrame::Binary(b"recent prompt".to_vec());
        registry
            .relay_from_agent(&created.terminal_id, frame)
            .await
            .expect("relay output");
        outbound.recv().await.expect("live output");
        registry
            .detach_operator(&created.terminal_id, &created.attachment_token)
            .await;
        let token = registry
            .issue_attachment_token_for_operator(&created.terminal_id, OPERATOR_A)
            .await
            .expect("reattach token");
        let mut remounted = registry
            .attach_operator(&created.terminal_id, &token, OPERATOR_A)
            .await
            .expect("reattach operator");
        assert!(remounted.try_recv().is_err());
    }
    #[tokio::test]
    async fn operator_input_waits_for_agent_attachment() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        let resize = TerminalRelayFrame::Text(r#"{"type":"resize","rows":30,"cols":120}"#.into());
        registry
            .relay_to_agent(&created.terminal_id, resize)
            .await
            .expect("queue resize before agent attachment");
        let (_, pending) = registry
            .attach_agent(&created.terminal_id, "router", &created.relay_token)
            .await
            .expect("attach agent");
        assert_eq!(pending.len(), 1);
        assert!(matches!(pending[0], TerminalRelayFrame::Text(_)));
    }
    #[tokio::test]
    async fn agent_can_hold_two_terminal_sessions() {
        let registry = TerminalRegistry::new();
        registry.create("router".into()).await.expect("first");
        registry.create("router".into()).await.expect("second");
        let third = registry.create("router".into()).await;
        assert_eq!(third.err(), Some("agent_terminal_limit_reached"));
    }
    #[tokio::test]
    async fn advertised_limit_controls_session_capacity() {
        let registry = TerminalRegistry::new();
        for _ in 0..3 {
            registry
                .create_with_limits("router".into(), 3, DEFAULT_TERMINAL_SESSION_TTL_SECONDS)
                .await
                .expect("within advertised limit");
        }
        let fourth = registry
            .create_with_limits("router".into(), 3, DEFAULT_TERMINAL_SESSION_TTL_SECONDS)
            .await;
        assert_eq!(fourth.err(), Some("agent_terminal_limit_reached"));
    }
    #[tokio::test]
    async fn session_ttl_is_captured_and_zero_is_unlimited() {
        let registry = TerminalRegistry::new();
        let finite = registry
            .create_with_limits("router".into(), 2, 67)
            .await
            .expect("finite session");
        assert_eq!(
            finite.expires_at_unix,
            finite.created_at_unix.checked_add(67)
        );
        registry.remove(&finite.terminal_id).await;
        let unlimited = registry
            .create_with_limits("router".into(), 2, 0)
            .await
            .expect("unlimited session");
        assert_eq!(unlimited.expires_at_unix, None);
        assert_eq!(
            registry
                .summary(&unlimited.terminal_id)
                .await
                .expect("unlimited summary")
                .expires_at_unix,
            None
        );
    }
    #[tokio::test]
    async fn unlimited_inventory_can_adopt_an_old_session() {
        let registry = TerminalRegistry::new();
        let terminal_id = TerminalId::new("old-unlimited").expect("terminal id");
        let reported = AgentTerminalSession {
            terminal_id: terminal_id.clone(),
            created_at_unix: 0,
            session_ttl_seconds: 0,
        };
        let credentials = registry
            .reconcile_agent_sessions("router", &[reported])
            .await;
        assert_eq!(credentials.len(), 1);
        assert_eq!(
            registry
                .summary(terminal_id.as_str())
                .await
                .expect("adopted unlimited session")
                .expires_at_unix,
            None
        );
    }
    #[tokio::test]
    async fn removed_session_is_distinct_from_unknown_session() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        assert!(!registry.was_closed(&created.terminal_id).await);
        assert!(!registry.was_closed("never-existed").await);
        registry.remove(&created.terminal_id).await.expect("remove");
        assert!(registry.was_closed(&created.terminal_id).await);
        assert!(!registry.was_closed("never-existed").await);
    }
    #[tokio::test]
    async fn agent_inventory_adopts_and_reconnects_live_session() {
        let registry = TerminalRegistry::new();
        let terminal_id = TerminalId::new("survived-cc").expect("terminal id");
        let created_at_unix = u64::MAX;
        let reported = AgentTerminalSession {
            terminal_id: terminal_id.clone(),
            created_at_unix,
            session_ttl_seconds: 0,
        };
        let credentials = registry
            .reconcile_agent_sessions("router", &[reported])
            .await;
        assert_eq!(credentials.len(), 1);
        let (_, relay_token) = &credentials[0];
        registry
            .attach_agent(terminal_id.as_str(), "router", relay_token)
            .await
            .expect("attach adopted agent session");
        let summary = registry
            .summary(terminal_id.as_str())
            .await
            .expect("adopted summary");
        assert_eq!(summary.agent_id, "router");
        assert_eq!(summary.created_at_unix, created_at_unix);
        assert!(summary.agent_attached);
    }
    #[tokio::test]
    async fn expired_sessions_release_agent_quota() {
        let registry = TerminalRegistry::new();
        let first = registry.create("router".into()).await.expect("first");
        registry.create("router".into()).await.expect("second");
        registry
            .inner
            .lock()
            .await
            .get_mut(&first.terminal_id)
            .expect("first session")
            .expiry = TerminalExpiry::Finite {
            deadline: Instant::now(),
            unix: first.created_at_unix,
        };
        registry
            .create("router".into())
            .await
            .expect("expired session no longer consumes quota");
        assert!(registry.summary(&first.terminal_id).await.is_none());
    }
    #[tokio::test]
    async fn reconciliation_does_not_revive_expired_agent_session() {
        let registry = TerminalRegistry::new();
        let terminal_id = TerminalId::new("expired-agent-session").expect("terminal id");
        let reported = AgentTerminalSession {
            terminal_id: terminal_id.clone(),
            created_at_unix: 0,
            session_ttl_seconds: DEFAULT_TERMINAL_SESSION_TTL_SECONDS,
        };
        assert!(
            registry
                .reconcile_agent_sessions("router", &[reported])
                .await
                .is_empty()
        );
        assert!(registry.summary(terminal_id.as_str()).await.is_none());
    }
    #[tokio::test]
    async fn operator_detach_does_not_remove_session() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        registry
            .attach_operator(&created.terminal_id, &created.attachment_token, OPERATOR_A)
            .await
            .expect("attach operator");
        registry
            .detach_operator(&created.terminal_id, &created.attachment_token)
            .await;
        let summary = registry
            .summary(&created.terminal_id)
            .await
            .expect("session remains after detach");
        assert!(!summary.operator_attached);
        registry
            .issue_attachment_token_for_operator(&created.terminal_id, OPERATOR_A)
            .await
            .expect("detached session can be reattached");
    }
    #[tokio::test]
    async fn attachment_handoff_releases_previous_operator_atomically() {
        let registry = TerminalRegistry::new();
        let previous = registry.create("router".into()).await.expect("previous");
        let next = registry.create("router".into()).await.expect("next");
        registry
            .attach_operator(
                &previous.terminal_id,
                &previous.attachment_token,
                OPERATOR_A,
            )
            .await
            .expect("attach previous");
        let next_token = registry
            .issue_attachment_token_for_operator(&next.terminal_id, OPERATOR_A)
            .await
            .expect("handoff token");
        assert!(
            !registry
                .summary(&previous.terminal_id)
                .await
                .unwrap()
                .operator_attached
        );
        registry
            .attach_operator(&next.terminal_id, &next_token, OPERATOR_A)
            .await
            .expect("attach next");
    }
    #[tokio::test]
    async fn attachment_handoff_does_not_evict_unrelated_operator() {
        let registry = TerminalRegistry::new();
        let previous = registry.create("router".into()).await.expect("previous");
        let occupied = registry.create("router".into()).await.expect("occupied");
        registry
            .attach_operator(
                &previous.terminal_id,
                &previous.attachment_token,
                OPERATOR_A,
            )
            .await
            .expect("attach previous");
        registry
            .attach_operator(
                &occupied.terminal_id,
                &occupied.attachment_token,
                OPERATOR_B,
            )
            .await
            .expect("attach occupied");
        let error = registry
            .issue_attachment_token_for_operator(&occupied.terminal_id, OPERATOR_A)
            .await
            .expect_err("occupied target remains protected");
        assert_eq!(error, "terminal_operator_already_attached");
        assert!(
            registry
                .summary(&previous.terminal_id)
                .await
                .unwrap()
                .operator_attached
        );
        assert!(
            registry
                .summary(&occupied.terminal_id)
                .await
                .unwrap()
                .operator_attached
        );
    }
    #[tokio::test]
    async fn stale_socket_cleanup_does_not_detach_replacement() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        let old_connection_id = created.attachment_token.clone();
        let _old_outbound = registry
            .attach_operator(&created.terminal_id, &created.attachment_token, OPERATOR_A)
            .await
            .expect("attach old socket");
        let replacement_token = registry
            .issue_attachment_token_for_operator(&created.terminal_id, OPERATOR_A)
            .await
            .expect("replace own socket");
        let _replacement_outbound = registry
            .attach_operator(&created.terminal_id, &replacement_token, OPERATOR_A)
            .await
            .expect("attach replacement socket");
        assert!(
            registry
                .detach_operator(&created.terminal_id, &old_connection_id)
                .await
                .is_none()
        );
        assert!(
            registry
                .summary(&created.terminal_id)
                .await
                .unwrap()
                .operator_attached
        );
    }
    #[tokio::test]
    async fn reconciliation_does_not_remove_open_request_still_in_flight() {
        let registry = TerminalRegistry::new();
        let created = registry.create("router".into()).await.expect("create");
        registry.reconcile_agent_sessions("router", &[]).await;
        assert!(registry.summary(&created.terminal_id).await.is_some());
    }
 }
@@ -1,5 +1,5 @@
 use anyhow::{Context, Result};
-use wakey_core::{Device, DeviceId};
+use wakey_core::{Device, DeviceEndpoint, DeviceId, EndpointSource};
 use super::Store;
 use super::helpers::core::*;
@@ -108,6 +108,48 @@ impl Store {
                    .context("failed inserting device ips")?;
            }
            sqlx::query(
                "DELETE FROM agent_device_endpoints WHERE agent_id = ?1 AND device_key = ?2",
            )
            .bind(agent_id)
            .bind(&device_key)
            .execute(&mut *tx)
            .await
            .context("failed deleting device endpoints")?;
            let endpoints = endpoints_for_storage(device);
            if !endpoints.is_empty() {
                let mut builder = sqlx::QueryBuilder::new(
                    "INSERT INTO agent_device_endpoints \
                     (agent_id, device_key, endpoint_key, source, mac, ip, hostname, interface, presence, first_seen_unix, last_seen_unix) ",
                );
                builder.push_values(endpoints, |mut b, endpoint| {
                    let first_seen = endpoint.first_seen_unix.unwrap_or(snapshot_time);
                    let last_seen = endpoint.last_seen_unix.unwrap_or(snapshot_time);
                    b.push_bind(agent_id)
                        .push_bind(device_key.clone())
                        .push_bind(endpoint_storage_key(&endpoint))
                        .push_bind(endpoint_source_to_str(endpoint.key.source))
                        .push_bind(
                            endpoint
                                .key
                                .mac
                                .map(|mac| mac.to_string().to_ascii_lowercase()),
                        )
                        .push_bind(endpoint.key.ip.map(|ip| ip.to_string()))
                        .push_bind(endpoint.hostname.clone())
                        .push_bind(endpoint.interface.clone())
                        .push_bind(presence_to_str(endpoint.presence))
                        .push_bind(i64::try_from(first_seen).unwrap_or(i64::MAX))
                        .push_bind(i64::try_from(last_seen).unwrap_or(i64::MAX));
                });
                builder
                    .build()
                    .execute(&mut *tx)
                    .await
                    .context("failed inserting device endpoints")?;
            }
            sqlx::query!(
                "DELETE FROM agent_device_hostnames WHERE agent_id = ?1 AND device_key = ?2",
                agent_id,
@@ -223,6 +265,15 @@ impl Store {
        .await
        .context("failed listing agent device hostnames")?;
        let endpoints = sqlx::query_as::<_, AgentDeviceEndpointRow>(
            r#"SELECT agent_id, device_key, endpoint_key, source, mac, ip,
                    hostname, interface, presence, first_seen_unix, last_seen_unix
             FROM agent_device_endpoints"#,
        )
        .fetch_all(&self.pool)
        .await
        .context("failed listing agent device endpoints")?;
        let facts = sqlx::query_as!(
            AgentDeviceFactRow,
            r#"SELECT agent_id as "agent_id!", device_key as "device_key!", fact_json as "fact_json!"
@@ -232,7 +283,9 @@ impl Store {
        .await
        .context("failed listing agent device facts")?;
-        Ok(assemble_device_rows(devices, macs, ips, hostnames, facts))
+        Ok(assemble_device_rows(
            devices, macs, ips, hostnames, endpoints, facts,
        ))
    }
    /// List agent device rows for a single agent.
@@ -287,6 +340,17 @@ impl Store {
        .await
        .context("failed listing agent device hostnames for agent")?;
        let endpoints = sqlx::query_as::<_, AgentDeviceEndpointRow>(
            r#"SELECT agent_id, device_key, endpoint_key, source, mac, ip,
                    hostname, interface, presence, first_seen_unix, last_seen_unix
             FROM agent_device_endpoints
             WHERE agent_id = ?1"#,
        )
        .bind(agent_id)
        .fetch_all(&self.pool)
        .await
        .context("failed listing agent device endpoints for agent")?;
        let facts = sqlx::query_as!(
            AgentDeviceFactRow,
            r#"SELECT agent_id as "agent_id!", device_key as "device_key!", fact_json as "fact_json!"
@@ -298,7 +362,9 @@ impl Store {
        .await
        .context("failed listing agent device facts for agent")?;
-        Ok(assemble_device_rows(devices, macs, ips, hostnames, facts))
+        Ok(assemble_device_rows(
            devices, macs, ips, hostnames, endpoints, facts,
        ))
    }
 }
@@ -307,6 +373,7 @@ fn assemble_device_rows(
    macs: Vec<AgentDeviceMacRow>,
    ips: Vec<AgentDeviceIpRow>,
    hostnames: Vec<AgentDeviceHostnameRow>,
    endpoints: Vec<AgentDeviceEndpointRow>,
    facts: Vec<AgentDeviceFactRow>,
 ) -> Vec<AgentDeviceWithChildren> {
    use std::collections::BTreeMap;
@@ -332,6 +399,15 @@ fn assemble_device_rows(
            .or_default()
            .push(row.hostname.clone());
    }
    let mut endpoint_map: BTreeMap<(&str, &str), Vec<DeviceEndpoint>> = BTreeMap::new();
    for row in &endpoints {
        if let Some(endpoint) = row.to_endpoint() {
            endpoint_map
                .entry((row.agent_id.as_str(), row.device_key.as_str()))
                .or_default()
                .push(endpoint);
        }
    }
    let mut fact_map: BTreeMap<(&str, &str), Vec<String>> = BTreeMap::new();
    for row in &facts {
        fact_map
@@ -369,11 +445,13 @@ fn assemble_device_rows(
                })
                .collect();
            let hostnames = hostname_map.get(&key).cloned().unwrap_or_default();
            let endpoints = endpoint_map.get(&key).cloned().unwrap_or_default();
            let facts = fact_map.get(&key).cloned().unwrap_or_default();
            AgentDeviceWithChildren {
                macs,
                ips,
                hostnames,
                endpoints,
                facts,
                device,
            }
@@ -397,6 +475,65 @@ fn presence_to_str(presence: wakey_core::Presence) -> &'static str {
    }
 }
 fn endpoint_source_to_str(source: EndpointSource) -> &'static str {
    match source {
        EndpointSource::Neighbor => "neighbor",
        EndpointSource::DhcpLease => "dhcp_lease",
        EndpointSource::HookNeighbor => "hook_neighbor",
        EndpointSource::HookDhcp => "hook_dhcp",
    }
 }
 fn endpoint_storage_key(endpoint: &DeviceEndpoint) -> String {
    format!(
        "{}|{}|{}",
        endpoint_source_to_str(endpoint.key.source),
        endpoint
            .key
            .mac
            .map(|mac| mac.to_string().to_ascii_lowercase())
            .unwrap_or_default(),
        endpoint.key.ip.map(|ip| ip.to_string()).unwrap_or_default()
    )
 }
 fn endpoints_for_storage(device: &Device) -> Vec<DeviceEndpoint> {
    if !device.endpoints.is_empty() {
        return device.endpoints.clone();
    }
    let mut endpoints = Vec::new();
    for neighbor in &device.neighbors {
        endpoints.push(DeviceEndpoint {
            key: wakey_core::EndpointKey {
                source: EndpointSource::Neighbor,
                mac: neighbor.mac,
                ip: Some(neighbor.ip),
            },
            hostname: None,
            interface: neighbor.dev.clone(),
            presence: wakey_core::Presence::from(neighbor.state),
            first_seen_unix: None,
            last_seen_unix: None,
        });
    }
    for lease in &device.leases {
        endpoints.push(DeviceEndpoint {
            key: wakey_core::EndpointKey {
                source: EndpointSource::DhcpLease,
                mac: Some(lease.mac),
                ip: Some(lease.ip),
            },
            hostname: lease.name.clone(),
            interface: None,
            presence: wakey_core::Presence::Unknown,
            first_seen_unix: None,
            last_seen_unix: None,
        });
    }
    endpoints
 }
 #[cfg(test)]
 mod tests {
    use super::super::helpers::test_helpers::TestStore;
@@ -412,6 +549,7 @@ mod tests {
            ips: vec![ip.parse().expect("ip")],
            macs: vec![mac.parse().expect("mac")],
            interfaces: vec!["br-lan".to_string()],
            endpoints: vec![],
            neighbors: vec![NeighborEntry {
                ip: ip.parse().expect("ip"),
                dev: Some("br-lan".to_string()),
@@ -457,6 +595,15 @@ mod tests {
            vec!["192.168.1.10".parse::<std::net::IpAddr>().unwrap()]
        );
        assert_eq!(rows[0].hostnames, vec!["first-pc"]);
        assert_eq!(rows[0].endpoints.len(), 1);
        assert_eq!(
            rows[0].endpoints[0].key.source,
            wakey_core::EndpointSource::Neighbor
        );
        assert_eq!(
            rows[0].endpoints[0].key.ip,
            Some("192.168.1.10".parse().expect("ip"))
        );
    }
    #[tokio::test]
@@ -582,6 +729,7 @@ mod tests {
            ips: vec![],
            macs: vec![],
            interfaces: vec![],
            endpoints: vec![],
            neighbors: vec![],
            leases: vec![],
            observations: vec![],
@@ -612,6 +760,7 @@ mod tests {
            ips: vec!["192.168.1.10".parse().expect("ip")],
            macs: vec!["aa:bb:cc:dd:ee:01".parse().expect("mac")],
            interfaces: vec![],
            endpoints: vec![],
            neighbors: vec![],
            leases: vec![],
            observations: vec![DeviceObservationFact {
@@ -216,7 +216,7 @@ impl Store {
        input: DeviceIdentifierInput,
    ) -> Result<Option<KnownDevice>> {
        let identifier = normalize_device_identifier(input)?;
-        let identifier_key = normalized_identifier_key_owned(identifier);
+        let identifier_key = identifier.identifier_key;
        let device_id = sqlx::query_scalar!(
            "SELECT device_id FROM device_identifiers WHERE identifier_key = ?1",
            identifier_key
@@ -70,11 +70,6 @@ pub fn normalize_device_identifier(
    })
 }
 #[cfg_attr(not(test), allow(dead_code))]
 pub fn normalized_identifier_key_owned(identifier: NormalizedDeviceIdentifier) -> String {
    identifier.identifier_key
 }
 pub async fn list_enroll_token_rows(pool: &SqlitePool) -> Result<Vec<EnrollTokenRow>> {
    sqlx::query_as!(
        EnrollTokenRow,
@@ -1,4 +1,5 @@
 use super::*;
 use tracing::{debug, info, warn};
 impl Store {
    pub async fn migrate_sqlite_state(
@@ -12,71 +13,53 @@ impl Store {
                from_sqlite_state.display()
            );
        }
-        if to_state_file.is_dir() {
+
        // 1. Safety check for destination
        if to_state_file.exists() && !force {
            anyhow::bail!(
-                "target state file {} is a directory",
+                "target state file {} already exists; use --force to overwrite",
                to_state_file.display()
            );
        }
        let is_same_file = match (
            std::fs::canonicalize(from_sqlite_state),
            std::fs::canonicalize(to_state_file),
        ) {
            (Ok(from_canon), Ok(to_canon)) => from_canon == to_canon,
            _ => from_sqlite_state == to_state_file,
        };
-        let actual_from_path = if is_same_file {
+        // 2. Setup temporary migration target
-            let mut bak = to_state_file.to_path_buf();
+        let mut temp_target = to_state_file.to_path_buf();
-            let mut file_name = bak.file_name().unwrap_or_default().to_os_string();
+        let mut temp_name = temp_target.file_name().unwrap_or_default().to_os_string();
-            file_name.push(".bak");
+        temp_name.push(".migration_tmp");
-            bak.set_file_name(file_name);
+        temp_target.set_file_name(temp_name);
-            if bak.exists() {
+        if temp_target.exists() {
-                if !force {
+            std::fs::remove_file(&temp_target)
-                    anyhow::bail!(
+                .context("failed to clean up stale migration temp file")?;
                        "backup file {} already exists; re-run with --force to overwrite",
                        bak.display()
                    );
                }
                std::fs::remove_file(&bak).with_context(|| {
                    format!("failed to remove existing backup {}", bak.display())
                })?;
        }
-            std::fs::rename(from_sqlite_state, &bak)
+        // 3. Initialize fresh schema on the temp file
-                .with_context(|| "failed to rename legacy state for in-place migration")?;
+        let store = Store::load_or_init(&temp_target, Vec::new(), Duration::from_secs(1)).await?;
            bak
        } else {
            if to_state_file.exists()
                && to_state_file
                    .metadata()
                    .with_context(|| format!("failed to stat {}", to_state_file.display()))?
                    .len()
                    > 0
            {
                if !force {
                    anyhow::bail!(
                        "target SQLite state file {} already exists and is non-empty; re-run with --force to overwrite",
                        to_state_file.display()
                    );
                }
                std::fs::remove_file(to_state_file)
                    .with_context(|| format!("failed to remove {}", to_state_file.display()))?;
            }
            from_sqlite_state.to_path_buf()
        };
-        let store = Store::load_or_init(to_state_file, Vec::new(), Duration::from_secs(1)).await?;
+        // 4. Use a single connection for the entire migration
        // ATTACH is connection-scoped, so we can't use the pool directly.
        let mut conn = store
            .pool
            .acquire()
            .await
            .context("failed to acquire migration connection")?;
-        let from_path_str = actual_from_path
+        let from_path_str = from_sqlite_state
            .to_str()
-            .ok_or_else(|| anyhow::anyhow!("invalid path"))?;
+            .ok_or_else(|| anyhow::anyhow!("invalid legacy path"))?;
        sqlx::query(&format!("ATTACH DATABASE '{}' AS legacy", from_path_str))
-            .execute(&store.pool)
+            .execute(&mut *conn)
            .await
-            .with_context(|| "failed to attach legacy database")?;
+            .with_context(|| format!("failed to attach legacy database at {}", from_path_str))?;
        let legacy_tables: Vec<String> =
            sqlx::query_scalar("SELECT name FROM legacy.sqlite_master WHERE type='table'")
                .fetch_all(&mut *conn)
                .await
                .context("failed to list tables in legacy database")?;
        debug!(?legacy_tables, "found tables in legacy database");
        let tables = [
            "meta",
@@ -91,16 +74,48 @@ impl Store {
        ];
        for table in tables {
-            let q = format!("INSERT INTO {} SELECT * FROM legacy.{}", table, table);
+            if !legacy_tables.contains(&table.to_string()) {
                warn!(table, "table missing in legacy database; skipping");
                continue;
            }
            let q = format!(
                "INSERT OR IGNORE INTO {} SELECT * FROM legacy.{}",
                table, table
            );
            sqlx::query(&q)
-                .execute(&store.pool)
+                .execute(&mut *conn)
                .await
                .with_context(|| format!("failed to migrate table {}", table))?;
        }
        sqlx::query("DETACH DATABASE legacy")
-            .execute(&store.pool)
+            .execute(&mut *conn)
-            .await?;
+            .await
            .context("failed to detach legacy database")?;
        // 5. Finalize: Force a checkpoint to roll up WAL, then close and move
        sqlx::query("PRAGMA wal_checkpoint(TRUNCATE)")
            .execute(&mut *conn)
            .await
            .context("failed to checkpoint WAL before finalization")?;
        // Explicitly drop the connection so the pool can close properly
        drop(conn);
        store.pool.close().await;
        // Clean up any "ghost" WAL/SHM files at the destination to prevent corruption
        let to_path_str = to_state_file.to_string_lossy();
        let _ = std::fs::remove_file(format!("{}-wal", to_path_str));
        let _ = std::fs::remove_file(format!("{}-shm", to_path_str));
        std::fs::rename(&temp_target, to_state_file)
            .context("failed to move migrated database into final location")?;
        // Also clean up any leftover temp WAL/SHM files just in case
        let temp_path_str = temp_target.to_string_lossy();
        let _ = std::fs::remove_file(format!("{}-wal", temp_path_str));
        let _ = std::fs::remove_file(format!("{}-shm", temp_path_str));
        info!(
            from = %from_sqlite_state.display(),
@@ -2,7 +2,7 @@ use std::path::PathBuf;
 use macaddr::MacAddr;
 use serde::{Deserialize, Serialize};
-use wakey_core::Presence;
+use wakey_core::{DeviceEndpoint, EndpointKey, EndpointSource, Presence};
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct IssuedAgent {
@@ -134,6 +134,66 @@ pub struct AgentDeviceHostnameRow {
    pub hostname: String,
 }
 #[derive(Debug, Clone, sqlx::FromRow)]
 pub struct AgentDeviceEndpointRow {
    pub agent_id: String,
    pub device_key: String,
    pub endpoint_key: String,
    pub source: String,
    pub mac: Option<String>,
    pub ip: Option<String>,
    pub hostname: Option<String>,
    pub interface: Option<String>,
    pub presence: String,
    pub first_seen_unix: i64,
    pub last_seen_unix: i64,
 }
 impl AgentDeviceEndpointRow {
    pub fn to_endpoint(&self) -> Option<DeviceEndpoint> {
        let source = endpoint_source_from_str(&self.source)?;
        let mac = match self.mac.as_deref() {
            Some(raw) => match raw.parse() {
                Ok(mac) => Some(mac),
                Err(err) => {
                    tracing::warn!(
                        error = %err,
                        endpoint_key = %self.endpoint_key,
                        raw_mac = raw,
                        "failed to parse endpoint mac"
                    );
                    return None;
                }
            },
            None => None,
        };
        let ip = match self.ip.as_deref() {
            Some(raw) => match raw.parse() {
                Ok(ip) => Some(ip),
                Err(err) => {
                    tracing::warn!(
                        error = %err,
                        endpoint_key = %self.endpoint_key,
                        raw_ip = raw,
                        "failed to parse endpoint ip"
                    );
                    return None;
                }
            },
            None => None,
        };
        let key = EndpointKey::new(source, mac, ip)?;
        Some(DeviceEndpoint {
            key,
            hostname: self.hostname.clone(),
            interface: self.interface.clone(),
            presence: Presence::from(self.presence.as_str()),
            first_seen_unix: Some(self.first_seen_unix.max(0) as u64),
            last_seen_unix: Some(self.last_seen_unix.max(0) as u64),
        })
    }
 }
 #[derive(Debug, Clone)]
 pub struct AgentDeviceFactRow {
    pub agent_id: String,
@@ -147,10 +207,24 @@ pub struct AgentDeviceWithChildren {
    pub macs: Vec<macaddr::MacAddr>,
    pub ips: Vec<std::net::IpAddr>,
    pub hostnames: Vec<String>,
    pub endpoints: Vec<DeviceEndpoint>,
    #[allow(dead_code)]
    pub facts: Vec<String>,
 }
 fn endpoint_source_from_str(raw: &str) -> Option<EndpointSource> {
    match raw {
        "neighbor" => Some(EndpointSource::Neighbor),
        "dhcp_lease" => Some(EndpointSource::DhcpLease),
        "hook_neighbor" => Some(EndpointSource::HookNeighbor),
        "hook_dhcp" => Some(EndpointSource::HookDhcp),
        _ => {
            tracing::warn!(source = raw, "unknown endpoint source");
            None
        }
    }
 }
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AuditEvent {
    pub event_id: String,
@@ -8,7 +8,11 @@ use std::time::Instant;
 use tokio::sync::mpsc;
 use tracing::{debug, info, info_span, warn};
 use uuid::Uuid;
-use wakey_agent::protocol::{ErrorPayload, RequestId, ServerMessage};
+use wakey_agent::protocol::{
    AgentCapability, AgentCapabilityOptions, AgentTerminalSession, DEFAULT_TERMINAL_MAX_SESSIONS,
    DEFAULT_TERMINAL_SESSION_TTL_SECONDS, ErrorPayload, RequestId, ServerMessage,
    TerminalCapabilityOptions, TerminalControl, TerminalId, checked_terminal_session_ttl,
 };
 use wakey_core::Device;
 use crate::runtime::{AgentReply, AgentSession, AppState, SessionEvent};
@@ -19,6 +23,10 @@ use crate::state::AuditEventInput;
 enum IncomingClientMessage {
    Hello {
        agent_id: String,
        #[serde(default)]
        capabilities: Vec<AgentCapability>,
        #[serde(default)]
        capability_options: AgentCapabilityOptions,
    },
    Auth {
        agent_id: String,
@@ -39,6 +47,22 @@ enum IncomingClientMessage {
        request_id: RequestId,
        error: ErrorPayload,
    },
    TerminalRejected {
        terminal_id: TerminalId,
        error: ErrorPayload,
    },
    TerminalSessions {
        sessions: Vec<AgentTerminalSession>,
    },
 }
 #[derive(Default)]
 struct AgentConnectionState {
    authed_agent_id: Option<String>,
    hello_agent_id: Option<String>,
    hello_at: Option<Instant>,
    capabilities: Vec<AgentCapability>,
    capability_options: AgentCapabilityOptions,
 }
 pub async fn agent_ws(ws: WebSocketUpgrade, State(state): State<AppState>) -> impl IntoResponse {
@@ -80,8 +104,7 @@ async fn handle_agent_socket(state: AppState, socket: WebSocket) {
        debug!("websocket writer loop ended");
    });
-    let mut authed_agent_id: Option<String> = None;
+    let mut connection = AgentConnectionState::default();
    let mut hello_at: Option<Instant> = None;
    loop {
        let frame = read.next().await;
@@ -103,8 +126,7 @@ async fn handle_agent_socket(state: AppState, socket: WebSocket) {
                    &state,
                    &tx,
                    &connection_id,
-                    &mut authed_agent_id,
+                    &mut connection,
                    &mut hello_at,
                    connected_at,
                    &text,
                )
@@ -126,7 +148,7 @@ async fn handle_agent_socket(state: AppState, socket: WebSocket) {
        }
    }
-    if let Some(agent_id) = authed_agent_id {
+    if let Some(agent_id) = connection.authed_agent_id {
        info!(agent_id = %agent_id, "agent disconnected");
        let mut sessions = state.sessions.write().await;
        let should_remove = sessions
@@ -136,6 +158,7 @@ async fn handle_agent_socket(state: AppState, socket: WebSocket) {
        if should_remove {
            sessions.remove(&agent_id);
        }
        drop(sessions);
        if let Err(err) = state
            .store
            .append_audit_event(AuditEventInput {
@@ -163,8 +186,7 @@ async fn process_agent_text(
    state: &AppState,
    tx: &mpsc::UnboundedSender<SessionEvent>,
    connection_id: &str,
-    authed_agent_id: &mut Option<String>,
+    connection: &mut AgentConnectionState,
    hello_at: &mut Option<Instant>,
    connected_at: Instant,
    text: &str,
 ) -> Result<()> {
@@ -172,20 +194,57 @@ async fn process_agent_text(
        serde_json::from_str(text).context("invalid client websocket payload")?;
    match message {
-        IncomingClientMessage::Hello { agent_id } => {
+        IncomingClientMessage::Hello {
            agent_id,
            capabilities,
            capability_options,
        } => {
            if connection
                .hello_agent_id
                .as_deref()
                .is_some_and(|hello_agent_id| hello_agent_id != agent_id)
            {
                anyhow::bail!("hello changed agent identity");
            }
            let now = Instant::now();
-            if hello_at.is_none() {
+            if connection.hello_at.is_none() {
-                *hello_at = Some(now);
+                connection.hello_at = Some(now);
            }
            let connect_to_hello_ms = connected_at.elapsed().as_millis() as u64;
            info!(agent_id = %agent_id, connect_to_hello_ms, "agent hello received");
            connection.hello_agent_id = Some(agent_id);
            let terminal = if capabilities.contains(&AgentCapability::Terminal) {
                let max_sessions = capability_options
                    .terminal
                    .as_ref()
                    .map(|terminal| terminal.max_sessions)
                    .unwrap_or(DEFAULT_TERMINAL_MAX_SESSIONS)
                    .max(1);
                let session_ttl_seconds = capability_options
                    .terminal
                    .as_ref()
                    .map(|terminal| terminal.session_ttl_seconds)
                    .unwrap_or(DEFAULT_TERMINAL_SESSION_TTL_SECONDS);
                checked_terminal_session_ttl(session_ttl_seconds).map_err(anyhow::Error::msg)?;
                Some(TerminalCapabilityOptions {
                    max_sessions,
                    session_ttl_seconds,
                })
            } else {
                None
            };
            connection.capability_options = AgentCapabilityOptions { terminal };
            connection.capabilities = capabilities;
        }
        IncomingClientMessage::Auth {
            agent_id,
            agent_token,
        } => {
            validate_auth_identity(connection, &agent_id)?;
            let connect_to_auth_ms = connected_at.elapsed().as_millis() as u64;
-            let hello_to_auth_ms = hello_at.map(|t| now_duration_ms(t.elapsed()));
+            let hello_to_auth_ms = connection
                .hello_at
                .map(|time| now_duration_ms(time.elapsed()));
            if !state
                .store
                .verify_agent_token(&agent_id, &agent_token)
@@ -219,9 +278,11 @@ async fn process_agent_text(
                AgentSession {
                    connection_id: connection_id.to_string(),
                    tx: tx.clone(),
                    capabilities: connection.capabilities.clone(),
                    capability_options: connection.capability_options.clone(),
                },
            );
-            *authed_agent_id = Some(agent_id.clone());
+            connection.authed_agent_id = Some(agent_id.clone());
            info!(agent_id = %agent_id, connect_to_auth_ms, hello_to_auth_ms = hello_to_auth_ms.unwrap_or(0), "agent authenticated");
            if let Err(err) = state
                .store
@@ -246,14 +307,14 @@ async fn process_agent_text(
            let _ = tx.send(SessionEvent::Message(ServerMessage::SyncDeviceSnapshot));
        }
        IncomingClientMessage::Heartbeat { agent_id } => {
-            if authed_agent_id.as_deref() != Some(agent_id.as_str()) {
+            if connection.authed_agent_id.as_deref() != Some(agent_id.as_str()) {
                anyhow::bail!("heartbeat for unauthenticated or mismatched agent");
            }
            ensure_current_session(state, &agent_id, connection_id).await?;
            debug!(agent_id = %agent_id, "heartbeat received");
        }
        IncomingClientMessage::DeviceSnapshot { agent_id, devices } => {
-            if authed_agent_id.as_deref() != Some(agent_id.as_str()) {
+            if connection.authed_agent_id.as_deref() != Some(agent_id.as_str()) {
                anyhow::bail!("device_snapshot for unauthenticated or mismatched agent");
            }
            ensure_current_session(state, &agent_id, connection_id).await?;
@@ -272,7 +333,8 @@ async fn process_agent_text(
            }
        }
        IncomingClientMessage::Result { request_id, result } => {
-            let agent_id = authed_agent_id
+            let agent_id = connection
                .authed_agent_id
                .as_deref()
                .ok_or_else(|| anyhow::anyhow!("result before auth"))?;
            ensure_current_session(state, agent_id, connection_id).await?;
@@ -284,7 +346,8 @@ async fn process_agent_text(
            }
        }
        IncomingClientMessage::Error { request_id, error } => {
-            let agent_id = authed_agent_id
+            let agent_id = connection
                .authed_agent_id
                .as_deref()
                .ok_or_else(|| anyhow::anyhow!("error before auth"))?;
            ensure_current_session(state, agent_id, connection_id).await?;
@@ -295,6 +358,48 @@ async fn process_agent_text(
                debug!(request_id = %key, "dropping unsolicited error from agent");
            }
        }
        IncomingClientMessage::TerminalRejected { terminal_id, error } => {
            let agent_id = connection
                .authed_agent_id
                .as_deref()
                .ok_or_else(|| anyhow::anyhow!("terminal rejection before auth"))?;
            ensure_current_session(state, agent_id, connection_id).await?;
            let error_json = serde_json::to_string(&TerminalControl::Error {
                code: error.code,
                message: error.message,
            })?;
            if let Err(code) = state
                .terminals
                .reject(terminal_id.as_str(), agent_id, error_json)
                .await
            {
                debug!(terminal_id = %terminal_id, agent_id, code, "dropping rejection for inactive terminal");
                return Ok(());
            }
            warn!(terminal_id = %terminal_id, agent_id, "agent rejected terminal request");
        }
        IncomingClientMessage::TerminalSessions { sessions } => {
            let agent_id = connection
                .authed_agent_id
                .as_deref()
                .ok_or_else(|| anyhow::anyhow!("terminal inventory before auth"))?;
            ensure_current_session(state, agent_id, connection_id).await?;
            let credentials = state
                .terminals
                .reconcile_agent_sessions(agent_id, &sessions)
                .await;
            for (terminal_id, relay_token) in credentials {
                let _ = tx.send(SessionEvent::Message(ServerMessage::ResumeTerminal {
                    terminal_id,
                    relay_token,
                }));
            }
            info!(
                agent_id,
                sessions = sessions.len(),
                "agent terminal sessions reconciled"
            );
        }
    }
    Ok(())
@@ -304,6 +409,17 @@ fn now_duration_ms(duration: std::time::Duration) -> u64 {
    duration.as_millis() as u64
 }
 fn validate_auth_identity(connection: &AgentConnectionState, agent_id: &str) -> Result<()> {
    let hello_agent_id = connection
        .hello_agent_id
        .as_deref()
        .ok_or_else(|| anyhow::anyhow!("auth before hello"))?;
    if hello_agent_id != agent_id {
        anyhow::bail!("auth agent does not match hello agent");
    }
    Ok(())
 }
 async fn ensure_current_session(
    state: &AppState,
    agent_id: &str,
@@ -335,10 +451,13 @@ mod tests {
    use std::collections::HashMap;
    use tokio::sync::mpsc;
    use wakey_agent::protocol::AgentCapabilityOptions;
    use crate::runtime::AgentSession;
-    use super::is_current_session;
+    use super::{
        AgentConnectionState, IncomingClientMessage, is_current_session, validate_auth_identity,
    };
    #[test]
    fn current_session_check_rejects_stale_connection_ids() {
@@ -349,6 +468,8 @@ mod tests {
            AgentSession {
                connection_id: "conn-new".to_string(),
                tx,
                capabilities: Vec::new(),
                capability_options: AgentCapabilityOptions::default(),
            },
        );
@@ -356,4 +477,30 @@ mod tests {
        assert!(!is_current_session(&sessions, "agent-a", "conn-old"));
        assert!(!is_current_session(&sessions, "agent-b", "conn-new"));
    }
    #[test]
    fn auth_requires_a_matching_hello_identity() {
        let mut connection = AgentConnectionState::default();
        assert!(validate_auth_identity(&connection, "agent-a").is_err());
        connection.hello_agent_id = Some("agent-a".into());
        assert!(validate_auth_identity(&connection, "agent-a").is_ok());
        assert!(validate_auth_identity(&connection, "agent-b").is_err());
    }
    #[test]
    fn legacy_hello_without_capability_options_deserializes() {
        let message: IncomingClientMessage = serde_json::from_str(
            r#"{"type":"hello","agent_id":"agent-a","capabilities":["terminal"]}"#,
        )
        .expect("deserialize legacy hello");
        let IncomingClientMessage::Hello {
            capability_options, ..
        } = message
        else {
            panic!("expected hello");
        };
        assert_eq!(capability_options, AgentCapabilityOptions::default());
    }
 }
@@ -1,6 +1,6 @@
 [package]
 name = "wakey-core"
-version = "0.3.0"
+version = "0.3.5"
 edition = "2024"
 publish = ["gitea"]
@@ -8,16 +8,16 @@ use crate::parse::mac;
 /// Product-level presence derived from raw neighbor state.
 ///
-/// Variant order defines `Ord`: Offline < Unknown < LikelyOnline < Online.
+/// Variant order defines `Ord`: Unknown < Offline < LikelyOnline < Online.
 /// `std::cmp::max` picks the most-online signal when merging.
 #[derive(
    Debug, PartialEq, Eq, Clone, Copy, Hash, Ord, PartialOrd, Serialize, Deserialize, Default,
 )]
 #[serde(rename_all = "snake_case")]
 pub enum Presence {
    Offline,
    #[default]
    Unknown,
    Offline,
    LikelyOnline,
    Online,
 }
@@ -71,11 +71,80 @@ pub enum DeviceId {
    Ip(IpAddr),
 }
 /// Typed origin of an endpoint.
 ///
 /// Raw source strings stay on `DeviceObservationFact` for debugging. Endpoint
 /// source is the domain value used for summaries and wake-route ranking.
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, Ord, PartialOrd, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum EndpointSource {
    Neighbor,
    DhcpLease,
    HookNeighbor,
    HookDhcp,
 }
 impl EndpointSource {
    /// Whether this source contributes an IP to the device summary.
    pub const fn summary_ip_eligible(self) -> bool {
        matches!(self, Self::Neighbor | Self::DhcpLease)
    }
    /// Source quality used after reachability and recency when ranking routes.
    pub const fn quality_rank(self) -> u8 {
        match self {
            Self::Neighbor => 4,
            Self::DhcpLease => 3,
            Self::HookNeighbor => 2,
            Self::HookDhcp => 1,
        }
    }
 }
 /// Source-scoped identity for one observed network contact point.
 #[skip_serializing_none]
 #[derive(Debug, PartialEq, Eq, Clone, Hash, Serialize, Deserialize)]
 pub struct EndpointKey {
    pub source: EndpointSource,
    #[serde(with = "mac::option_mac", default)]
    pub mac: Option<MacAddr>,
    pub ip: Option<IpAddr>,
 }
 impl EndpointKey {
    pub fn new(source: EndpointSource, mac: Option<MacAddr>, ip: Option<IpAddr>) -> Option<Self> {
        if mac.is_none() && ip.is_none() {
            return None;
        }
        Some(Self { source, mac, ip })
    }
 }
 /// Agent-scoped endpoint key used by control-plane storage and APIs.
 #[derive(Debug, PartialEq, Eq, Clone, Hash, Serialize, Deserialize)]
 pub struct AgentEndpointKey {
    pub agent_id: String,
    #[serde(flatten)]
    pub endpoint: EndpointKey,
 }
 /// One interpreted network contact point for a device aggregate.
 #[skip_serializing_none]
 #[derive(Debug, PartialEq, Eq, Clone, Hash, Serialize, Deserialize)]
 pub struct DeviceEndpoint {
    pub key: EndpointKey,
    pub hostname: Option<String>,
    pub interface: Option<String>,
    pub presence: Presence,
    pub first_seen_unix: Option<u64>,
    pub last_seen_unix: Option<u64>,
 }
 /// One raw source fact used while building a device aggregate.
 ///
 /// These are intentionally source-shaped and non-durable. They preserve details
-/// from hooks and live inventory so higher layers can explain why a device looks
+/// from hooks (arp, dhcp, etc) so higher layers can explain why a device looks
-/// online, stale, or unknown without reverse-engineering flattened fields.
+/// online, stale, or unknown.
 #[skip_serializing_none]
 #[derive(Debug, PartialEq, Eq, Clone, Hash, Serialize, Deserialize)]
 pub struct DeviceObservationFact {
@@ -102,6 +171,8 @@ pub struct Device {
    #[serde(with = "mac::vec_mac")]
    pub macs: Vec<MacAddr>,
    pub interfaces: Vec<String>,
    #[serde(default)]
    pub endpoints: Vec<DeviceEndpoint>,
    pub neighbors: Vec<NeighborEntry>,
    pub leases: Vec<DhcpLease>,
    pub observations: Vec<DeviceObservationFact>,
@@ -126,6 +197,7 @@ impl Device {
        let mut ips = BTreeSet::new();
        let mut macs = BTreeSet::new();
        let mut interfaces = BTreeSet::new();
        let mut endpoints = Vec::new();
        let mut presence = Presence::Unknown;
        for lease in &leases {
@@ -134,6 +206,18 @@ impl Device {
            if let Some(name) = lease.name.as_deref() {
                names.insert(name);
            }
            endpoints.push(DeviceEndpoint {
                key: EndpointKey {
                    source: EndpointSource::DhcpLease,
                    mac: Some(lease.mac),
                    ip: Some(lease.ip),
                },
                hostname: lease.name.clone(),
                interface: None,
                presence: Presence::Unknown,
                first_seen_unix: None,
                last_seen_unix: None,
            });
        }
        for neighbor in &neighbors {
            ips.insert(neighbor.ip);
@@ -143,46 +227,61 @@ impl Device {
            if let Some(dev) = neighbor.dev.as_deref() {
                interfaces.insert(dev);
            }
-            presence = std::cmp::max(presence, Presence::from(neighbor.state));
+            let endpoint_presence = Presence::from(neighbor.state);
            endpoints.push(DeviceEndpoint {
                key: EndpointKey {
                    source: EndpointSource::Neighbor,
                    mac: neighbor.mac,
                    ip: Some(neighbor.ip),
                },
                hostname: None,
                interface: neighbor.dev.clone(),
                presence: endpoint_presence,
                first_seen_unix: None,
                last_seen_unix: None,
            });
            presence = std::cmp::max(presence, endpoint_presence);
        }
-        let mut observed_non_remove = false;
+
        for observation in &observations {
            if let Some(name) = observation.hostname.as_deref() {
                names.insert(name);
            }
            if let Some(ip) = observation.ip {
                ips.insert(ip);
            }
            if let Some(mac) = observation.mac {
                macs.insert(mac);
            }
-            if observation.action != "remove" {
+            if let Some(source) = observation_endpoint_source(observation)
-                observed_non_remove = true;
+                && let Some(key) = EndpointKey::new(source, observation.mac, observation.ip)
            }
            presence = std::cmp::max(presence, observation_presence(observation));
        }
        if neighbors.is_empty()
            && leases.is_empty()
            && !observed_non_remove
            && !observations.is_empty()
            {
-            presence = Presence::Offline;
+                let endpoint_presence = observation_presence(observation);
                endpoints.push(DeviceEndpoint {
                    key,
                    hostname: observation.hostname.clone(),
                    interface: None,
                    presence: endpoint_presence,
                    first_seen_unix: observation.first_seen_unix,
                    last_seen_unix: observation.last_seen_unix,
                });
                presence = std::cmp::max(presence, endpoint_presence);
            }
        }
        let macs: Vec<MacAddr> = macs.into_iter().collect();
        let ips: Vec<IpAddr> = ips.into_iter().collect();
-        let id = macs
+        let id = macs.first().copied().map(DeviceId::Mac).or_else(|| {
-            .first()
+            endpoints
-            .copied()
+                .iter()
-            .map(DeviceId::Mac)
+                .filter_map(|endpoint| endpoint.key.ip)
-            .or_else(|| ips.first().copied().map(DeviceId::Ip));
+                .min()
                .map(DeviceId::Ip)
        });
        Self {
            id,
            names: names.into_iter().map(|n| n.to_owned()).collect(),
            ips,
            macs,
            interfaces: interfaces.into_iter().map(|d| d.to_owned()).collect(),
            endpoints,
            neighbors,
            leases,
            observations,
@@ -193,14 +292,23 @@ impl Device {
 fn observation_presence(observation: &DeviceObservationFact) -> Presence {
    match (observation.kind.as_str(), observation.action.as_str()) {
-        (_, "remove") => Presence::Offline,
+        ("neigh", "remove") => Presence::Offline,
        ("neigh", "add" | "update" | "old") => Presence::LikelyOnline,
        _ => Presence::Unknown,
    }
 }
 fn observation_endpoint_source(observation: &DeviceObservationFact) -> Option<EndpointSource> {
    match observation.kind.as_str() {
        "neigh" => Some(EndpointSource::HookNeighbor),
        "dhcp" => Some(EndpointSource::HookDhcp),
        _ => None,
    }
 }
 /// Collection of merged discovered devices.
-#[derive(Debug, Default, Clone, Serialize)]
+#[derive(Debug, Default, Clone, Serialize, Deserialize)]
 pub struct DeviceInventory {
    #[serde(default)]
    pub devices: Vec<Device>,
 }
@@ -5,7 +5,10 @@ mod neighbor;
 mod query;
 mod wake;
-pub use device::{Device, DeviceId, DeviceInventory, DeviceObservationFact, Presence};
+pub use device::{
    AgentEndpointKey, Device, DeviceEndpoint, DeviceId, DeviceInventory, DeviceObservationFact,
    EndpointKey, EndpointSource, Presence,
 };
 #[allow(deprecated)]
 pub use dhcp::LeaseQuery;
 pub use dhcp::{DhcpLease, DhcpLeaseWithState};
@@ -1,16 +1,16 @@
 [package]
 name = "wakey-linux"
-version = "0.3.0"
+version = "0.3.5"
 edition = "2024"
 publish = ["gitea"]
 [dependencies]
-anyhow = "1"
+anyhow = { workspace = true }
 futures = "0"
-macaddr = { version = "1", features = ["serde", "serde_std"] }
+macaddr = { workspace = true }
-serde = { version = "1", features = ["derive"] }
+serde = { workspace = true }
-serde_json = "1"
+serde_json = { workspace = true }
-tokio = { version = "1", features = ["fs", "net", "rt", "sync"] }
+tokio = { workspace = true, features = ["net", "sync"] }
 wakey-core = { path = "../wakey-core", registry = "gitea", version = "0"}
 [dev-dependencies]
@@ -21,3 +21,11 @@ path = "../ipjs"
 registry = "gitea"
 version = "0"
 features = ["experimental-nl"]
 [target.'cfg(unix)'.dependencies]
 nix = { version = "0.31", default-features = false, features = [
    "signal",
    "process",
    "term",
 ] }
 pty-process = { version = "0.5", features = ["async"] }
@@ -3,9 +3,13 @@
 pub mod devices;
 pub mod dhcp;
 pub mod observations;
 #[cfg(unix)]
 pub mod terminal;
 pub mod wake;
 pub use devices::*;
 pub use dhcp::*;
 pub use observations::*;
 #[cfg(unix)]
 pub use terminal::*;
 pub use wake::*;
@@ -161,6 +161,38 @@ pub async fn prune_removed_observations_from_path(path: impl AsRef<Path>) -> io:
    Ok(removed)
 }
 pub async fn prune_stale_observations_from_path(
    path: impl AsRef<Path>,
    retention_days: u64,
 ) -> io::Result<usize> {
    if retention_days == 0 {
        return Ok(0);
    }
    let max_age_seconds = retention_days.saturating_mul(24 * 60 * 60);
    prune_observations_older_than_from_path(path, now_unix().saturating_sub(max_age_seconds)).await
 }
 async fn prune_observations_older_than_from_path(
    path: impl AsRef<Path>,
    cutoff_unix: u64,
 ) -> io::Result<usize> {
    let path = path.as_ref();
    let mut store = load_observation_store_from_path(path).await?;
    let before = store.dhcp_clients.len() + store.neighbors.len();
    store
        .dhcp_clients
        .retain(|_, row| row.last_seen_unix >= cutoff_unix);
    store
        .neighbors
        .retain(|_, row| row.last_seen_unix >= cutoff_unix);
    let after = store.dhcp_clients.len() + store.neighbors.len();
    let removed = before.saturating_sub(after);
    if removed > 0 {
        save_observation_store_to_path(path, &store).await?;
    }
    Ok(removed)
 }
 fn list_local_observations_from_store(store: LocalObservationStore) -> Vec<LocalDeviceObservation> {
    let mut out = Vec::with_capacity(store.dhcp_clients.len() + store.neighbors.len());
    out.extend(
@@ -235,11 +267,11 @@ pub async fn observe_dhcp_event(
                row.hostname = hostname.clone();
                row.last_action = action.to_string();
                row.last_seen_unix = now;
-                changed = true;
+                changed = true; // update row
            }
        })
        .or_insert_with(|| {
-            changed = true;
+            changed = true; // insert new row
            ObservedDhcpClient {
                mac: mac_s.clone(),
                ip,
@@ -258,7 +290,7 @@ pub async fn observe_dhcp_event(
        if cache.get(&mac_s).map(|v| v != &hostname).unwrap_or(true) {
            cache.insert(mac_s, hostname);
            save_mac_name_cache(&cache).await?;
-            changed = true;
+            changed = true; // update mac -> name cache... 
        }
    }
@@ -292,7 +324,7 @@ pub async fn observe_neighbor_event(
                .find_map(|alias| store.neighbors.remove(alias))
        })
        .unwrap_or_else(|| {
-            changed = true;
+            changed = true; // append
            ObservedNeighbor {
                key: key.clone(),
                mac: mac.clone(),
@@ -304,7 +336,7 @@ pub async fn observe_neighbor_event(
        });
    for alias in alias_keys {
        if store.neighbors.remove(&alias).is_some() {
-            changed = true;
+            changed = true; // remove old alias
        }
    }
    if row.key != key
@@ -318,7 +350,7 @@ pub async fn observe_neighbor_event(
        row.ip = ip;
        row.last_action = action.clone();
        row.last_seen_unix = now;
-        changed = true;
+        changed = true; // something changed
    }
    store.neighbors.insert(key, row);
    if let (Some(mac), Some(ip)) = (mac.as_deref(), ip)
@@ -387,6 +419,7 @@ fn mark_replaced_neighbor_ips_removed(
        let Some(row_ip) = row.ip else {
            continue;
        };
        // found another ip for same mac, mark it as removed
        if row.mac.as_deref() == Some(mac)
            && row_ip != current_ip
            && same_ip_family(row_ip, current_ip)
@@ -412,7 +445,7 @@ mod tests {
    use serial_test::serial;
    struct EnvGuard {
-        keys: Vec<&'static str>,
+        keys: Vec<&'static str>, // vec of 1 key
    }
    impl EnvGuard {
@@ -576,4 +609,56 @@ mod tests {
        let _ = tokio::fs::remove_file(observation_path).await;
    }
    #[tokio::test]
    #[serial]
    async fn stale_observation_prune_uses_last_seen_cutoff() {
        let observation_path = temp_file("stale-observations");
        let mut dhcp_clients = std::collections::BTreeMap::new();
        dhcp_clients.insert(
            "aa:bb:cc:dd:ee:01".to_string(),
            ObservedDhcpClient {
                mac: "aa:bb:cc:dd:ee:01".to_string(),
                ip: Some("192.168.1.2".parse().expect("ip")),
                hostname: Some("old".to_string()),
                first_seen_unix: 1,
                last_seen_unix: 10,
                last_action: "remove".to_string(),
            },
        );
        dhcp_clients.insert(
            "aa:bb:cc:dd:ee:02".to_string(),
            ObservedDhcpClient {
                mac: "aa:bb:cc:dd:ee:02".to_string(),
                ip: Some("192.168.1.3".parse().expect("ip")),
                hostname: Some("new".to_string()),
                first_seen_unix: 1,
                last_seen_unix: 20,
                last_action: "remove".to_string(),
            },
        );
        let fixture = LocalObservationStore {
            dhcp_clients,
            neighbors: Default::default(),
        };
        tokio::fs::write(
            &observation_path,
            serde_json::to_string(&fixture).expect("fixture should serialize"),
        )
        .await
        .expect("fixture should write");
        let removed = prune_observations_older_than_from_path(&observation_path, 15)
            .await
            .expect("prune should succeed");
        assert_eq!(removed, 1);
        let store = load_observation_store_from_path(&observation_path)
            .await
            .expect("store should read");
        assert!(!store.dhcp_clients.contains_key("aa:bb:cc:dd:ee:01"));
        assert!(store.dhcp_clients.contains_key("aa:bb:cc:dd:ee:02"));
        let _ = tokio::fs::remove_file(observation_path).await;
    }
 }
@@ -0,0 +1,207 @@
 //! Unix PTY ownership for interactive agent terminal sessions.
 use std::os::fd::{AsFd, OwnedFd};
 use std::path::Path;
 use std::pin::Pin;
 use std::task::{Context as TaskContext, Poll};
 use anyhow::{Context, Result};
 use pty_process::{Command, OwnedReadPty, OwnedWritePty, Size};
 use tokio::io::AsyncWrite;
 use tokio::process::Child;
 /// An interactive child process and the independently owned sides of its PTY.
 ///
 /// Keeping the write half available is important: `OwnedWritePty` also owns the
 /// resize operation used by terminal WebSocket control frames.
 pub struct TerminalPty {
    reader: OwnedReadPty,
    writer: TerminalWriter,
    child: Child,
 }
 /// Writable PTY half with the control operations needed by the agent.
 pub struct TerminalWriter {
    io: OwnedWritePty,
    control: OwnedFd,
 }
 impl TerminalPty {
    /// Starts a configured program attached to a newly allocated PTY.
    ///
    /// Wakey retains control of the PTY streams, terminal environment, and
    /// kill-on-drop behavior; callers may only select arguments and a working
    /// directory.
    pub fn spawn(
        program: &Path,
        args: &[String],
        current_dir: Option<&Path>,
        rows: u16,
        cols: u16,
    ) -> Result<Self> {
        let (pty, pts) = pty_process::open().context("failed to open PTY")?;
        pty.resize(Size::new(rows, cols))
            .context("failed to set initial PTY size")?;
        let control = pty
            .as_fd()
            .try_clone_to_owned()
            .context("failed to duplicate PTY control descriptor")?;
        // The remote frontend is xterm.js regardless of the daemon's own
        // environment, so advertise the terminal the child actually receives.
        let mut command = Command::new(program)
            .args(args)
            .env("TERM", "xterm-256color")
            .env("COLORTERM", "truecolor")
            .kill_on_drop(true);
        if let Some(current_dir) = current_dir {
            command = command.current_dir(current_dir);
        }
        let child = command
            .spawn(pts)
            .with_context(|| format!("failed to spawn {} in PTY", program.display()))?;
        let (reader, io) = pty.into_split();
        Ok(Self {
            reader,
            writer: TerminalWriter { io, control },
            child,
        })
    }
    /// Consumes the terminal into independently driven async parts.
    pub fn into_parts(self) -> (OwnedReadPty, TerminalWriter, Child) {
        (self.reader, self.writer, self.child)
    }
 }
 impl TerminalWriter {
    pub fn resize(&self, rows: u16, cols: u16) -> Result<()> {
        self.io
            .resize(Size::new(rows, cols))
            .context("failed to resize PTY")
    }
    /// Requests a full-screen application to redraw after reattachment.
    ///
    /// Job-control shells give foreground programs their own process groups,
    /// so signaling the original shell group would miss programs like `btop`.
    pub fn refresh(&self) -> Result<()> {
        let foreground = nix::unistd::tcgetpgrp(&self.control)
            .context("failed to get PTY foreground process group")?;
        nix::sys::signal::killpg(foreground, nix::sys::signal::Signal::SIGWINCH)
            .context("failed to signal PTY foreground process group")
    }
 }
 impl AsyncWrite for TerminalWriter {
    fn poll_write(
        mut self: Pin<&mut Self>,
        cx: &mut TaskContext<'_>,
        buf: &[u8],
    ) -> Poll<std::io::Result<usize>> {
        Pin::new(&mut self.io).poll_write(cx, buf)
    }
    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut TaskContext<'_>) -> Poll<std::io::Result<()>> {
        Pin::new(&mut self.io).poll_flush(cx)
    }
    fn poll_shutdown(
        mut self: Pin<&mut Self>,
        cx: &mut TaskContext<'_>,
    ) -> Poll<std::io::Result<()>> {
        Pin::new(&mut self.io).poll_shutdown(cx)
    }
 }
 #[cfg(test)]
 mod tests {
    use std::time::Duration;
    use tokio::io::{AsyncReadExt, AsyncWriteExt};
    use super::*;
    /// This test intentionally uses the same PTY implementation on the router.
    /// Run it remotely with:
    ///
    /// `./scripts/test_remote.ps1 -Package wakey-linux -Filter terminal::tests::pty_round_trip_and_resize -Exact -ShowOutput`
    #[tokio::test]
    #[ignore = "live system check, requires PTY and shell"]
    async fn pty_round_trip_and_resize() {
        let (mut reader, mut writer, mut child) =
            TerminalPty::spawn(Path::new("/bin/sh"), &[], None, 24, 80)
                .expect("spawn PTY shell")
                .into_parts();
        writer.resize(31, 101).expect("resize owned PTY writer");
        // Print the size from the parent shell after `stty` exits, so observing
        // the marker also means foreground control has returned to the shell.
        // Then wait for the literal probe; WINCH can interrupt a plain `read`.
        writer
            .write_all(
                b"trap 'printf \"WAKEY_WINCH\\n\"' WINCH; \
                  printf 'WAKEY_ENV:%s:%s\\n' \"$TERM\" \"$COLORTERM\"; \
                  size=$(stty size); printf 'WAKEY_SIZE:%s\\n' \"$size\"; \
                  line=; while [ \"$line\" != probe ]; do read line || line=; done; \
                  printf 'WAKEY_PTY_OK:%s\\n' \"$line\"; exit 0\n",
            )
            .await
            .expect("write shell input");
        let mut output = Vec::new();
        read_until(
            &mut reader,
            &mut output,
            "WAKEY_ENV:xterm-256color:truecolor",
        )
        .await;
        read_until(&mut reader, &mut output, "WAKEY_SIZE:31 101").await;
        writer.refresh().expect("signal foreground process group");
        writer
            .write_all(b"probe\n")
            .await
            .expect("write shell probe");
        let output = tokio::time::timeout(Duration::from_secs(5), async {
            read_until(&mut reader, &mut output, "WAKEY_PTY_OK:probe").await;
            output
        })
        .await
        .expect("PTY output timed out");
        let status = tokio::time::timeout(Duration::from_secs(5), child.wait())
            .await
            .expect("PTY child wait timed out")
            .expect("wait for PTY child");
        assert!(status.success(), "shell exited with {status}");
        let output = String::from_utf8_lossy(&output);
        assert!(
            output.contains("WAKEY_PTY_OK:probe"),
            "unexpected PTY output: {output:?}"
        );
        assert!(
            output.contains("WAKEY_SIZE:31 101"),
            "PTY did not report resized dimensions: {output:?}"
        );
        assert!(
            output.contains("WAKEY_WINCH"),
            "foreground process did not receive SIGWINCH: {output:?}"
        );
    }
    async fn read_until(reader: &mut OwnedReadPty, output: &mut Vec<u8>, marker: &str) {
        tokio::time::timeout(Duration::from_secs(5), async {
            let mut chunk = [0_u8; 4096];
            while !String::from_utf8_lossy(output).contains(marker) {
                // Use a fresh ReadBuf for each PTY read. pty-process 0.5.3's
                // AsyncRead implementation cannot safely extend Tokio's
                // partially filled buffer used by `read_to_end`.
                let count = reader.read(&mut chunk).await.expect("read PTY output");
                assert_ne!(count, 0, "PTY closed before emitting {marker}");
                output.extend_from_slice(&chunk[..count]);
            }
        })
        .await
        .unwrap_or_else(|_| panic!("PTY output timed out waiting for {marker}"));
    }
 }