fix(tci server): announce transmit permission, and log what the client sends

MSHV's PTT test does nothing against the TCI sharing server.

The initialisation block never carried TX_ENABLE. The document files it under
unidirectional control rather than initialisation, so it was missed when the
block was written from §4.1 — but its own note says it is "sent to the client
when connected", and that is the point: a client that models transmit
permission starts out assuming it may NOT transmit. Without it MSHV never even
tries, so nothing arrives to relay and there is nothing to see at either end.

Sent as true always. OpsLog is not what decides — the radio behind whichever
backend is connected does, and its refusal already travels back through SetPTT
into the log.

TX_FREQUENCY goes with it, at connect and whenever the transmit frequency
moves. It is the command a client showing "TX 14.200" reads; channel B alone
left that stale.

And every command a client sends is now logged. This is the only evidence there
will ever be about a program on someone else's machine: "the PTT test does
nothing" cannot be answered without knowing whether MSHV sent trx at all, and
in what form. Cheap — TCI is event-driven, a client speaks when the operator
does something — and capped at 200 lines per connection so one that does poll
cannot quietly fill the log.

If this was not the cause, the next report answers it in one line rather than
another round of guessing.

internal/tciserver/tciserver.go

@@ -91,10 +91,16 @@ type state struct {
 	valid bool
 }
 
+// clientLogCap bounds how many of one client's commands reach the log.
+const clientLogCap = 200
+
 // client is one connected program.
 type client struct {
 	conn *websocket.Conn
 	mu   sync.Mutex // one writer at a time: gorilla panics on concurrent writes
+	// logged counts what has been written to the log for this connection. Only
+	// the reader goroutine touches it, so it needs no lock of its own.
+	logged int
 }
 
 func (c *client) send(s string) error {
@@ -211,9 +217,27 @@ func (s *Server) serve(c *client, remote string) {
 		}
 		// One frame may carry several ";"-terminated commands.
 		for _, cmd := range strings.Split(string(data), ";") {
-			if cmd = strings.TrimSpace(cmd); cmd != "" {
-				s.handle(c, cmd)
+			if cmd = strings.TrimSpace(cmd); cmd == "" {
+				continue
 			}
+			// Every command the client sends, in the log.
+			//
+			// This is the only evidence there will ever be about a program on
+			// someone else's machine: "MSHV's PTT test does nothing" is
+			// unanswerable without knowing whether MSHV sent trx at all, and if
+			// so in what form. Cheap, because TCI is event-driven — a client
+			// speaks when the operator does something, not on a timer.
+			//
+			// Capped so a client that DOES poll cannot quietly fill the
+			// operator's log; the cap says so once and then stays quiet.
+			if c.logged < clientLogCap {
+				c.logged++
+				s.log("tci server: ← %s;", cmd)
+			} else if c.logged == clientLogCap {
+				c.logged++
+				s.log("tci server: (further commands from this client are not logged)")
+			}
+			s.handle(c, cmd)
 		}
 	}
 	s.mu.Lock()
@@ -250,6 +274,20 @@ func (s *Server) initBlock() []string {
 		fmt.Sprintf("modulation:0,%s;", mode),
 		fmt.Sprintf("split_enable:0,%t;", split),
 		"trx:0,false;",
+		// TRANSMIT PERMISSION, and it is not optional in practice.
+		//
+		// The document files TX_ENABLE under unidirectional control rather than
+		// initialisation, but its own note says it is "sent to the client when
+		// connected". A client that models permission — and one written for
+		// ExpertSDR users has every reason to — starts out assuming it may NOT
+		// transmit, and without this it never even tries: PTT does nothing and
+		// the server never sees a trx command to refuse.
+		//
+		// Always true. OpsLog is not the thing that decides: the radio behind
+		// whichever backend is connected does, and its refusal comes back through
+		// SetPTT and into the log.
+		"tx_enable:0,true;",
+		fmt.Sprintf("tx_frequency:%d;", tx),
 	}
 }
 
@@ -307,6 +345,9 @@ func (s *Server) publish() []string {
 	}
 	if !prev.valid || prev.txHz != cur.txHz {
 		lines = append(lines, fmt.Sprintf("vfo:0,1,%d;", cur.txHz))
+		// The transmit frequency has its own command, which is what a client
+		// showing "TX 14.080" reads. Channel B alone leaves that stale.
+		lines = append(lines, fmt.Sprintf("tx_frequency:%d;", cur.txHz))
 	}
 	if (!prev.valid || prev.mode != cur.mode) && cur.mode != "" {
 		lines = append(lines, fmt.Sprintf("modulation:0,%s;", cur.mode))