terminal

backend/Odin.py

@@ -235,6 +235,30 @@ async def require_admin(authorization: str = Header(None)):
     return user
 
 
+# ---------------------------------------------------------------------------
+# Admin log relay — live view of backend logs without the Space console.
+# The relay mirror lives in src/core/log_relay.py and is installed by
+# src/core/log.py setup_logging(); only these two endpoints expose it.
+# ---------------------------------------------------------------------------
+
+@app.get("/api/logs")
+async def get_log_lines(
+    since: int = Query(default=0, ge=0),
+    _user: dict = Depends(require_admin),
+):
+    """Return relayed log lines newer than `since`; `next` is the poll cursor."""
+    from src.core.log_relay import relay_lines
+    return relay_lines(since)
+
+
+@app.post("/api/logs/clear")
+async def clear_log_lines(_user: dict = Depends(require_admin)):
+    """Clear the in-memory relay buffer. The live log file is left intact."""
+    from src.core.log_relay import clear_relay
+    clear_relay()
+    return {"ok": True}
+
+
 def _print_agent_plans(engine):
     """Print each agent's full action plan to the CLI."""
     from src.core.agent_registry import AgentRuntimeState

backend/src/core/log.py

@@ -5,7 +5,9 @@ and level stay consistent across the engine, planner, and server.
 
 Architecture: a dependency of every backend module; no business logic.
 Design: logs land in backend/output/logs with timestamps for post-hoc
-analysis of long runs.
+analysis of long runs. Console output is off by default — the admin log
+terminal (src/core/log_relay.py) mirrors every line to the live log file
+and the admin-only /api/logs endpoints instead.
 """
 
 from __future__ import annotations
@@ -37,7 +39,7 @@ def _build_log_path(run_id: Optional[str] = None) -> Path:
 def setup_logging(
         level: int = DEFAULT_LEVEL,
         run_id: Optional[str] = None,
-        console: bool = True,
+        console: bool = False,
         file: bool = True,
         max_bytes: int = 5 * 1024 * 1024,
         backup_count: int = 5,
@@ -53,7 +55,8 @@ def setup_logging(
     run_id        -- optional tag folded into the log filename, e.g. a
                       persona name or simulation id, so a run's logs are
                       easy to find in output/logs/
-    console       -- also stream logs to stdout
+    console       -- also stream logs to stdout (default off; watch the
+                      admin log terminal instead)
     file          -- also write logs to output/logs/<timestamp>[_<run_id>].log
     max_bytes /
     backup_count  -- rotation settings for the file handler
@@ -113,6 +116,14 @@ def setup_logging(
     logging.config.dictConfig(config)
     _configured = True
 
+    # Mirror every emitted line into the admin log terminal's buffer and the
+    # live log file, regardless of the console/file toggles above.
+    try:
+        from src.core.log_relay import install_relay
+        install_relay()
+    except Exception:
+        pass
+
     if log_path:
         logging.getLogger(__name__).info("[log] logging initialized -> %s", log_path)
 

backend/src/core/log_relay.py

@@ -0,0 +1,82 @@
+"""log_relay — mirror of every project log line for the admin log terminal.
+
+Attaches a second handler to the ROOT logger: each emitted record is
+formatted with the project's standard format and appended to a bounded
+in-memory ring buffer (polled by the admin-only /api/logs endpoints) and
+to a live file backend/output/logs/live.log, so the same output also
+survives restarts and stays viewable without the Space console.
+
+Architecture: installed once by src/core/log.py setup_logging(); consumed
+by Odin.py's admin-gated endpoints and the frontend LogTerminal panel.
+Design: stdlib-only, a one-way mirror — never changes existing handlers,
+levels, or the file rotation policy.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from collections import deque
+from itertools import count
+
+from src.config import LOG_DIR
+from src.core.log import DATE_FORMAT, LOG_FORMAT
+
+MAX_LINES = 2000
+LIVE_LOG_PATH = LOG_DIR / "live.log"
+
+_seq = count(1)
+_buffer: deque = deque(maxlen=MAX_LINES)
+_latest_seq = 0
+_lock = threading.Lock()
+_installed = False
+
+
+class LogRelayHandler(logging.Handler):
+    """Appends each formatted record to the ring buffer and the live file."""
+
+    def __init__(self, level: int = logging.NOTSET) -> None:
+        super().__init__(level)
+        self._formatter = logging.Formatter(LOG_FORMAT, DATE_FORMAT)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        global _latest_seq
+        try:
+            text = self._formatter.format(record)
+        except Exception:
+            text = f"{record.name} | {record.getMessage()}"
+        with _lock:
+            _latest_seq = next(_seq)
+            _buffer.append({"seq": _latest_seq, "level": record.levelname, "text": text})
+        try:
+            LOG_DIR.mkdir(parents=True, exist_ok=True)
+            with open(LIVE_LOG_PATH, "a", encoding="utf-8") as fh:
+                fh.write(text + "\n")
+        except OSError:
+            pass
+
+
+def install_relay() -> None:
+    """Attach the relay handler to the root logger exactly once."""
+    global _installed
+    if _installed:
+        return
+    logging.getLogger().addHandler(LogRelayHandler())
+    _installed = True
+
+
+def relay_lines(since: int = 0) -> dict:
+    """Return relayed entries with seq > since, plus the latest seq as cursor.
+
+    The cursor tracks the last emitted sequence, so polling stays
+    incremental even after the buffer is cleared.
+    """
+    with _lock:
+        lines = [entry for entry in _buffer if entry["seq"] > since]
+        return {"lines": lines, "next": _latest_seq}
+
+
+def clear_relay() -> None:
+    """Drop the in-memory buffer (the live file is intentionally kept)."""
+    with _lock:
+        _buffer.clear()

frontend/src/App.jsx

@@ -23,6 +23,7 @@ import EventsPanel from "./components/EventsPanel";
 import DebugPanel from "./components/DebugPanel";
 import RosterManager from "./components/RosterManager";
 import LoginButton from "./components/LoginButton";
+import LogTerminal from "./components/LogTerminal";
 import { apiUrl } from "./utils/api";
 import "./App.css";
 
@@ -56,6 +57,7 @@ function AppContent() {
   const [controlError, setControlError] = useState(null);
   const [simulationRunning, setSimulationRunning] = useState(true);
   const [rosterOpen, setRosterOpen] = useState(false);
+  const [showTerminal, setShowTerminal] = useState(false);
 
   useEffect(() => {
     if (!snapshot) return;
@@ -153,6 +155,7 @@ function AppContent() {
       <EventsPanel events={snapshot?.events} />
       {showDebug && <DebugPanel health={snapshot?.health} />}
       <RosterManager open={rosterOpen} onClose={() => setRosterOpen(false)} simulationRunning={simulationRunning} onError={setControlError} isAuthenticated={isAuthenticated} />
+      {isAuthenticated && showTerminal && <LogTerminal onClose={() => setShowTerminal(false)} />}
 
       {agentIds.map((id, index) => {
         const expanded = expandedAgentIds.has(id);
@@ -185,6 +188,8 @@ function AppContent() {
         }}
         onToggleRoster={() => setRosterOpen((value) => !value)}
         isAuthenticated={isAuthenticated}
+        terminalOpen={showTerminal}
+        onToggleTerminal={() => setShowTerminal((value) => !value)}
       />
       <LoginButton />
     </div>

frontend/src/components/InfoBar.jsx

@@ -13,7 +13,7 @@
 
 import { useState } from "react";
 
-export default function InfoBar({ snapshot, showDebug, onToggleDebug, onFastForward, onSlowDown, onRewind, simulationRunning, onToggleSimulation, onToggleRoster, isAuthenticated }) {
+export default function InfoBar({ snapshot, showDebug, onToggleDebug, onFastForward, onSlowDown, onRewind, simulationRunning, onToggleSimulation, onToggleRoster, isAuthenticated, terminalOpen, onToggleTerminal }) {
   const [rewindAmount, setRewindAmount] = useState("10");
   const [rewindUnit, setRewindUnit] = useState("ticks");
   if (!snapshot) return null;
@@ -140,11 +140,20 @@ export default function InfoBar({ snapshot, showDebug, onToggleDebug, onFastForw
         {showDebug ? "DEBUG ON" : "DEBUG"}
       </button>
       {isAuthenticated && (
-        <button onClick={onToggleRoster} style={{
-          pointerEvents: "auto", border: "1px solid rgba(212,160,74,.3)", borderRadius: 3,
-          background: "rgba(212,160,74,.08)", color: "#e7bd70", padding: "2px 5px",
-          fontFamily: "'Space Mono', monospace", fontSize: 8, cursor: "pointer",
-        }} title="Add, retire, or rename agents while the simulation is stopped">ROSTER</button>
+        <>
+          <button onClick={onToggleRoster} style={{
+            pointerEvents: "auto", border: "1px solid rgba(212,160,74,.3)", borderRadius: 3,
+            background: "rgba(212,160,74,.08)", color: "#e7bd70", padding: "2px 5px",
+            fontFamily: "'Space Mono', monospace", fontSize: 8, cursor: "pointer",
+          }} title="Add, retire, or rename agents while the simulation is stopped">ROSTER</button>
+          <button onClick={onToggleTerminal} style={{
+            pointerEvents: "auto", border: "1px solid rgba(91,155,213,.3)", borderRadius: 3,
+            background: terminalOpen ? "rgba(91,155,213,.22)" : "transparent", color: "#8fbbe8", padding: "2px 5px",
+            fontFamily: "'Space Mono', monospace", fontSize: 8, cursor: "pointer",
+          }} title="Open the live backend log terminal">
+            {terminalOpen ? "TERMINAL ON" : "TERMINAL"}
+          </button>
+        </>
       )}
     </div>
   );

frontend/src/components/LogTerminal.jsx

@@ -0,0 +1,189 @@
+/**
+ * LogTerminal — admin-only live view of the backend log relay.
+ *
+ * Polls GET /api/logs?since=<cursor> with the admin bearer token and
+ * renders the captured logger output as a read-only terminal.
+ *
+ * Architecture: rendered by App.jsx only for authenticated users; toggled
+ * by the TERMINAL button in InfoBar.
+ *
+ * Design: 2s REST polling reuses the existing bearer-token flow instead of
+ * adding WebSocket authentication; auto-scroll halts while the pointer is
+ * over the terminal so lines can be read mid-stream.
+ */
+
+import { useEffect, useRef, useState, useCallback } from "react";
+import { useAuth } from "../hooks/useAuth";
+import { apiUrl } from "../utils/api";
+
+const POLL_MS = 2000;
+const LEVEL_COLORS = {
+  DEBUG: "#6b6b78",
+  INFO: "#8fbbe8",
+  WARNING: "#e7bd70",
+  ERROR: "#ff8b8b",
+  CRITICAL: "#ff6b6b",
+};
+
+export default function LogTerminal({ onClose }) {
+  const { token } = useAuth();
+  const [lines, setLines] = useState([]);
+  const [cursor, setCursor] = useState(0);
+  const [error, setError] = useState(null);
+  const [paused, setPaused] = useState(false);
+  const bodyRef = useRef(null);
+  const pausedRef = useRef(false);
+
+  const fetchNew = useCallback(async () => {
+    try {
+      const res = await fetch(apiUrl(`/api/logs?since=${cursor}`), {
+        headers: token ? { Authorization: `Bearer ${token}` } : {},
+      });
+      if (!res.ok) throw new Error(`Log fetch failed (${res.status})`);
+      const data = await res.json();
+      if (data.lines?.length) {
+        setLines((previous) => [...previous.slice(-2000), ...data.lines]);
+      }
+      if (typeof data.next === "number") setCursor(data.next);
+      setError(null);
+    } catch (err) {
+      setError(err.message);
+    }
+  }, [cursor, token]);
+
+  useEffect(() => {
+    fetchNew();
+    const timer = setInterval(fetchNew, POLL_MS);
+    return () => clearInterval(timer);
+  }, [fetchNew]);
+
+  useEffect(() => {
+    const el = bodyRef.current;
+    if (el && !pausedRef.current) el.scrollTop = el.scrollHeight;
+  }, [lines]);
+
+  async function clearLogs() {
+    try {
+      const res = await fetch(apiUrl("/api/logs/clear"), {
+        method: "POST",
+        headers: token ? { Authorization: `Bearer ${token}` } : {},
+      });
+      if (!res.ok) throw new Error(`Clear failed (${res.status})`);
+      setLines([]);
+    } catch (err) {
+      setError(err.message);
+    }
+  }
+
+  async function copyLogs() {
+    try {
+      await navigator.clipboard.writeText(lines.map((line) => line.text).join("\n"));
+    } catch {
+      /* clipboard unavailable — ignore */
+    }
+  }
+
+  const headerButton = {
+    background: "rgba(91,155,213,.08)",
+    border: "1px solid rgba(91,155,213,.30)",
+    borderRadius: 3,
+    color: "#8fbbe8",
+    padding: "2px 6px",
+    fontFamily: "'Space Mono', monospace",
+    fontSize: 8,
+    cursor: "pointer",
+  };
+
+  return (
+    <aside
+      style={{
+        position: "fixed",
+        right: 16,
+        top: 66,
+        bottom: 96,
+        width: 460,
+        maxWidth: "calc(100vw - 32px)",
+        display: "flex",
+        flexDirection: "column",
+        background: "rgba(8,10,12,0.95)",
+        backdropFilter: "blur(8px)",
+        border: "1px solid rgba(91,155,213,0.30)",
+        borderRadius: 6,
+        boxShadow: "0 14px 44px rgba(0,0,0,0.6)",
+        fontFamily: "'Space Mono', monospace",
+        zIndex: 1300,
+      }}
+    >
+      <header
+        style={{
+          display: "flex",
+          alignItems: "center",
+          gap: 8,
+          padding: "8px 12px",
+          borderBottom: "1px solid rgba(255,255,255,0.07)",
+        }}
+      >
+        <span style={{ color: "#8fbbe8", fontWeight: 700, fontSize: 10, letterSpacing: "0.14em" }}>
+          LOG TERMINAL
+        </span>
+        <span style={{ fontSize: 9, color: "#6b6b78" }}>{lines.length} lines</span>
+        <span style={{ flex: 1 }} />
+        <button onClick={copyLogs} style={headerButton} title="Copy all relayed lines to the clipboard">
+          COPY
+        </button>
+        <button onClick={clearLogs} style={headerButton} title="Clear the in-memory relay buffer">
+          CLEAR
+        </button>
+        <button onClick={onClose} style={headerButton} title="Close the log terminal">
+          X
+        </button>
+      </header>
+
+      <div
+        ref={bodyRef}
+        onMouseEnter={() => {
+          pausedRef.current = true;
+          setPaused(true);
+        }}
+        onMouseLeave={() => {
+          pausedRef.current = false;
+          setPaused(false);
+        }}
+        style={{
+          flex: 1,
+          overflowY: "auto",
+          padding: "10px 12px",
+          fontSize: 9,
+          lineHeight: 1.65,
+        }}
+      >
+        {lines.length === 0 && (
+          <div style={{ color: "#6b6b78" }}>no lines yet — the relay captures log output once the simulation starts</div>
+        )}
+        {lines.map((entry) => (
+          <div
+            key={entry.seq}
+            style={{
+              color: LEVEL_COLORS[entry.level] || "#d0d0da",
+              whiteSpace: "pre-wrap",
+              wordBreak: "break-word",
+            }}
+          >
+            {entry.text}
+          </div>
+        ))}
+      </div>
+
+      <footer
+        style={{
+          padding: "6px 12px",
+          borderTop: "1px solid rgba(255,255,255,0.07)",
+          fontSize: 9,
+          color: error ? "#ff8b8b" : paused ? "#e7bd70" : "#6b6b78",
+        }}
+      >
+        {error ? `ERROR: ${error}` : paused ? "PAUSED — move the pointer away to resume auto-scroll" : "TAILING — 2s poll"}
+      </footer>
+    </aside>
+  );
+}