v46: show evidenced agent activity and readable chat queue progress

Author: Mantiee

V100_AUDIT.md

@@ -401,3 +401,25 @@ history isolation, host receipts, rejection before desktop execution, archive/re
 recovery, preservation of later plans and refusal to repair a running mission.
 Ruff, formatting, shell syntax and diff whitespace checks passed. Hardware/LAN
 allocation and useful execution still require the operator's deployment receipts.
+
+## v100.46 observed agent activity and readable chat
+
+The trusted live renderer adds per-agent cards for observed state, assigned task,
+inference device/model, declared conclusion or next step, last tool result, recorded
+ time and evidence file. Declarations remain explicitly unverified; no private
+reasoning/thinking fields are selected. Missing declarations stay absent. The read
+budget remains two daily tails of 128 KiB, 40 events and 16 recent jobs. Hardware
+readiness is not attributed as agent execution. Host CSS improves old saved layouts
+without replacing operator/master guest HTML. The same validated guest editor remains
+available. Browsers already open during installation need a full page refresh.
+
+Terminal chat separates user, master and action receipts, displays queue position
+or active processing elapsed time every 15 seconds, and exits cleanly on Ctrl+C
+without cancelling mission work. Identical pending messages reuse their request ID.
+These UI changes do not raise helper pacing/resource caps or prove useful allocation.
+
+Validation: 972 tests passed, 65 skipped, 1 owned-worker integration deselected and
+one PEFT configuration warning. Tests execute the trusted renderer on an old layout,
+cover pending-request deduplication, queue/processing labels, clean interruption,
+source attribution and omission of private reasoning fields. Ruff, shell syntax
+and diff whitespace checks passed. No V100/Windows/LAN execution is certified here.

pyproject.toml

@@ -3,7 +3,7 @@ name = "rlms"
 authors = [
     {name = "Alex Zhang", email = "altzhang@mit.edu"},
 ]
-version = "0.1.3+v100.45"
+version = "0.1.3+v100.46"
 description = "Recursive Language Models."
 readme = "README.md"
 license = "MIT"

rlm/v100/dashboard_layout.py

@@ -19,14 +19,15 @@
 <section><h2>Paper A/B</h2><pre id="paper"></pre><h3>Blokady</h3><pre id="blockers"></pre></section>
 <section><h2>Raporty HTML z wykresami i pliki wyników</h2><p class="muted">Raporty są zapisanymi migawkami, mają własny czas i zakres.</p><div id="reports"></div></section>
 <section><h2>Co teraz pracuje</h2><div id="actors" class="grid"></div><h3>Cele i plany</h3><pre id="goals"></pre><h3>Ostatnie zdarzenia</h3><div id="events"></div></section>
-<section><h2>Pomocnicy, GUI i benchmark oficjalny</h2><pre id="workers"></pre></section>
-<section><h2>Aktualny log kontrolera</h2><pre id="log"></pre></section>
+<details><summary>Pomocnicy, GUI i benchmark oficjalny - dane źródłowe</summary><pre id="workers"></pre></details>
+<details><summary>Aktualny log kontrolera</summary><pre id="log"></pre></details>
 <details><summary>Dowody treningu i ostatnie błędy</summary><pre id="evidence"></pre></details>
 <script>
 const $=id=>document.getElementById(id), fmt=x=>x===null||x===undefined?'brak potwierdzonych danych':String(x), pct=x=>typeof x==='number'&&Number.isFinite(x)?(x*100).toFixed(2)+'%':'brak danych';
 const layoutVersion='__LAYOUT_SHA__';
 function card(label,value){const node=document.createElement('div');node.className='card';const title=document.createElement('small');title.textContent=label;const strong=document.createElement('strong');strong.className='value';strong.textContent=fmt(value);node.append(title,strong);$('cards').append(node)}
 function workView(data){
+agentView(data);
 for(const id of ['actors','goals','events']){if(!$(id)){const node=document.createElement(id==='goals'?'pre':'div');node.id=id;if(id==='actors')node.className='grid';$('cards').after(node)}}
 $('actors').replaceChildren();
 for(const a of data.live?.actors||[]){
@@ -39,6 +40,13 @@
  for(const j of a.jobs||[]){const p=document.createElement('p');p.textContent=[j.kind,j.branch,j.state||j.phase,j.id,j.assignment].filter(Boolean).join(' | ');node.append(p)}
  const proof=document.createElement('details'),summary=document.createElement('summary'),raw=document.createElement('pre');summary.textContent='Dane źródłowe';raw.textContent=JSON.stringify(a,null,2);proof.append(summary,raw);node.append(proof);$('actors').append(node)
 }
+function agentView(data){
+let panel=$('agent-panel');if(!panel){panel=document.createElement('section');panel.id='agent-panel';const title=document.createElement('h2');title.textContent='Agent activity - tasks, decisions and evidence';const note=document.createElement('p');note.className='muted';note.textContent='Public conclusions and observed tool results. Declarations are not proof of execution. Internal reasoning is not displayed.';const grid=document.createElement('div');grid.id='agent-grid';grid.className='grid';panel.append(title,note,grid);$('cards').after(panel)}
+let grid=$('agent-grid');grid.replaceChildren();
+for(const a of data.live?.agents||[]){const node=document.createElement('article');node.className='card agent';const heading=document.createElement('h3');heading.textContent=a.label;node.append(heading);
+for(const [label,value] of [['Observed state',a.state],['Inference device',a.device],['Model',a.model],['Assigned task',a.task],['Tool',a.tool],['Declared conclusion / next step (unverified)',a.declaration],['Last observed result',a.result],['Recorded at',typeof a.updated==='number'?new Date(a.updated*1000).toLocaleString():a.updated],['Evidence file',a.source]]){if(value){const p=document.createElement('p'),b=document.createElement('strong');b.textContent=label+': ';p.append(b,document.createTextNode(String(value)));node.append(p)}}grid.append(node)}
+if(!grid.children.length){const p=document.createElement('p');p.textContent='No recent agent evidence. No activity is inferred from device readiness.';grid.append(p)}
+}
 const plans=data.live?.goals||{};$('goals').textContent=[['long','Cel długoterminowy'],['mid','Plan średnioterminowy'],['short','Plan krótkoterminowy']].map(([key,label])=>label+': '+(plans[key]?.text||'brak planu')+(plans[key]?.needs_replanning?' (wymaga przeplanowania)':'')).join('\n\n');
 $('events').replaceChildren();for(const e of [...(data.live?.events||[])].reverse().slice(0,20)){const p=document.createElement('p');p.textContent=[e.time,e.actor,e.kind,e.tool,e.detail].filter(Boolean).join(' | ');$('events').append(p)}
 }
@@ -62,6 +70,21 @@
 GUEST_TEMPLATE = "/workspace/dashboard/index.html"
 REQUIRED_IDS = set(re.findall(r"\$\('([a-z]+)'\)", APP_SCRIPT)) - {"actors", "goals", "events"}
 
+HOST_STYLE = """
+:root{color-scheme:dark;--line:#2b4058;--muted:#a6b7cc}
+body{max-width:1440px;margin:auto;padding:28px;background:#0b1220;color:#e7eef9;font:15px/1.6 system-ui}
+h1{font-size:32px;letter-spacing:-1px;margin-bottom:8px}h2{font-size:21px;margin-top:0}h3{font-size:16px;overflow-wrap:anywhere}
+section,details{background:#111e30;border:1px solid var(--line);border-radius:16px;padding:22px;margin:20px 0}
+.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:14px}
+.card{background:#16263b;border:1px solid var(--line);border-radius:12px;padding:18px;margin:0;min-width:0}
+.agent{border-top:3px solid #75c5ae}.agent p{font-size:13px;overflow-wrap:anywhere}.agent strong{color:#9ac5ff}
+#agent-panel{border-color:#487087}#actors .card{border-top:3px solid #82aef9}.muted,small{color:var(--muted)}
+.value{font-size:24px}pre{background:#0c1726;border-radius:8px;padding:14px;font-size:12px;max-height:280px;overflow:auto;white-space:pre-wrap;overflow-wrap:anywhere}
+summary{cursor:pointer;color:#9ac5ff}#events p{padding:10px 14px;border-left:2px solid #487087;background:#0c1726;font-size:12px;overflow-wrap:anywhere}
+button{background:#365c87;padding:10px 18px;border-radius:8px}progress{accent-color:#75c5ae}td,th{padding:12px;border-bottom:1px solid var(--line)}
+@media(max-width:650px){body{padding:12px}.grid{grid-template-columns:1fr}section,details{padding:14px}h1{font-size:26px}}
+"""
+
 
 def validate_css(value):
     value = re.sub(r"/\*.*?\*/", "", value, flags=re.S).lower()
@@ -136,7 +159,13 @@ def validate_template(content):
 
 
 def render_template(content, identity):
-    script = "<script>" + APP_SCRIPT.replace("__LAYOUT_SHA__", identity) + "</script>"
+    script = (
+        "<style>"
+        + HOST_STYLE
+        + "</style><script>"
+        + APP_SCRIPT.replace("__LAYOUT_SHA__", identity)
+        + "</script>"
+    )
     return re.sub(
         r"</html\s*>\s*\Z", lambda match: script + match.group(), content, count=1, flags=re.I
     )

rlm/v100/live_status.py

@@ -7,6 +7,27 @@
 import requests
 
 
+def public_summary(value: dict) -> str:
+    """Select public conclusions only; never expose reasoning/thinking token fields."""
+    if not isinstance(value, dict):
+        return ""
+    parts = []
+    for key in (
+        "answer",
+        "hypothesis",
+        "rationale",
+        "next_test",
+        "confidence",
+        "status",
+        "error",
+        "detail",
+        "report",
+    ):
+        if isinstance(value.get(key), (str, int, float)):
+            parts.append(f"{key}: {str(value[key])[:360]}")
+    return " | ".join(parts)[:800]
+
+
 def recent_events(root: Path, limit: int = 40) -> list[dict]:
     paths = sorted((root / "research/logs/activity").glob("*/timeline.jsonl"))[-2:]
     events = []
@@ -34,11 +55,64 @@ def recent_events(root: Path, limit: int = 40) -> list[dict]:
                         "kind": row.get("kind"),
                         "tool": payload.get("tool"),
                         "detail": str(payload.get("error", payload.get("status", "")))[:250],
+                        "summary": public_summary(payload.get("content", {}))
+                        or public_summary(payload.get("result", {}))
+                        or public_summary(payload),
+                        "category": row.get("category"),
+                        "source": str(path),
+                        "device": payload.get("device"),
+                        "model": payload.get("model"),
+                        "task": " | ".join(
+                            f"{key}: {str(payload.get('arguments', {}).get(key))[:200]}"
+                            for key in ("query", "url", "brief", "kind", "action")
+                            if isinstance(payload.get("arguments"), dict)
+                            and key in payload["arguments"]
+                        ),
                     }
                 )
     return events[-limit:]
 
 
+def agent_views(events: list[dict], jobs: list[dict]) -> list[dict]:
+    """Observed agent activity plus labelled declarations, not inferred intentions."""
+    views = {}
+    for event in events:
+        key = (event.get("branch"), event.get("actor"))
+        view = views.setdefault(
+            key,
+            {"label": " / ".join(str(v) for v in key if v), "declaration": "", "result": ""},
+        )
+        view.update(
+            updated=event.get("time"),
+            state=event.get("kind"),
+            tool=event.get("tool"),
+            source=event.get("source"),
+        )
+        if event.get("task"):
+            view["task"] = event["task"]
+        if event.get("device"):
+            view["device"] = event["device"]
+            view["model"] = event.get("model")
+        if event.get("category") == "decisions" and event.get("summary"):
+            view["declaration"] = event["summary"]
+        elif event.get("summary"):
+            view["result"] = event["summary"]
+    result = list(views.values())[-12:]
+    for job in jobs[:16]:
+        result.append(
+            {
+                "label": f"{job['branch']} / {job['kind']} / {job['id']}",
+                "state": job["state"],
+                "task": job.get("assignment", ""),
+                "updated": job.get("updated"),
+                "result": public_summary(job.get("result") or {}),
+                "declaration": "",
+                "source": "research/state/drones.sqlite3",
+            }
+        )
+    return result
+
+
 def current_chat(root: Path, mission: dict) -> dict:
     path = root / "research/state/chat-active.json"
     if not path.exists():
@@ -127,7 +201,7 @@ def snapshot(root: Path, mission: dict, report: dict, gpu: dict) -> dict:
         "label": "RTX helper",
         "state": "unknown",
         "jobs": [j for j in active if j["kind"] in ("researcher", "critic", "benchmark")],
-        "detail": "Utilization and power unknown; request pacing is not a hard GPU cap",
+        "detail": "Jobs eligible for helper; actual inference device is recorded in agent events. Utilization and power unknown; request pacing is not a hard GPU cap",
         "stale": True,
     }
     from rlm.v100.common import load_profile
@@ -172,10 +246,12 @@ def snapshot(root: Path, mission: dict, report: dict, gpu: dict) -> dict:
             if remaining and not rtx["stale"]:
                 rtx["state"] = "cooldown"
     actors.append(rtx)
+    events = recent_events(root)
     return {
         "observed_at": now,
         "actors": actors,
         "goals": read(root),
-        "events": recent_events(root),
+        "events": events,
+        "agents": agent_views(events, jobs),
         "chat": chat,
     }

rlm/v100/mission_chat.py

@@ -44,6 +44,12 @@ def submit(root: Path, message: str) -> str:
     identity = uuid.uuid4().hex
     with connect(root) as db:
         db.execute("BEGIN IMMEDIATE")
+        pending = db.execute(
+            "SELECT id FROM requests WHERE state='queued' AND message=? ORDER BY rowid LIMIT 1",
+            (message,),
+        ).fetchone()
+        if pending:
+            return pending["id"]
         if db.execute("SELECT count(*) FROM requests WHERE state='queued'").fetchone()[0] >= 32:
             raise ValueError("Chat queue has 32 pending requests; let them complete first")
         db.execute(
@@ -56,9 +62,18 @@ def submit(root: Path, message: str) -> str:
 def inspect(root: Path, identity: str) -> dict:
     with connect(root) as db:
         row = db.execute("SELECT * FROM requests WHERE id=?", (identity,)).fetchone()
+        position = (
+            db.execute(
+                "SELECT count(*) FROM requests WHERE state='queued' AND rowid<=(SELECT rowid FROM requests WHERE id=?)",
+                (identity,),
+            ).fetchone()[0]
+            if row is not None and row["state"] == "queued"
+            else None
+        )
     if row is None:
         raise ValueError("Unknown chat request")
     result = dict(row)
+    result["queue_position"] = position
     if result["response"]:
         result["response"] = json.loads(result["response"])
     active_path = root / "research/state/chat-active.json"
@@ -583,21 +598,36 @@ def alongside(root: Path, directory: Path):
             accepted_cpu.close()
 
 
-def wait_reply(root: Path, identity: str, timeout: float = 120) -> dict:
+def wait_reply(root: Path, identity: str, timeout: float = 120, progress=None) -> dict:
     deadline = time.monotonic() + timeout
+    next_update = time.monotonic()
     while time.monotonic() < deadline:
         result = inspect(root, identity)
         if result["state"] != "queued":
             return result
+        if progress is not None and time.monotonic() >= next_update:
+            progress(result)
+            next_update = time.monotonic() + 15
         time.sleep(0.5)
     return inspect(root, identity)
 
 
+def waiting_label(result: dict) -> str:
+    active = result.get("processing")
+    if active:
+        elapsed = max(0, round(time.time() - active["started"]))
+        return f"Processing: {elapsed}s elapsed | budget {active.get('time_budget_seconds', '?')}s | request {result['id']}"
+    text = f"Queued: position {result.get('queue_position', '?')} | request {result['id']}"
+    if result.get("error"):
+        text += " | last recorded issue: " + result["error"]
+    return text
+
+
 def chat(root: Path, message: str | None = None) -> None:
-    print("Czat misji. /exit kończy tylko czat. Podczas treningu lub gry polecenie może czekać.")
+    print("\nV100 MASTER CHAT\n/exit closes chat only. /status reads mission status.\n")
     while True:
         try:
-            text = message if message is not None else input("Ty> ")
+            text = message if message is not None else input("\nYOU > ")
         except (EOFError, KeyboardInterrupt):
             break
         if text.strip() == "/exit":
@@ -609,19 +639,33 @@ def chat(root: Path, message: str | None = None) -> None:
                 break
             continue
         identity = submit(root, text)
-        print("Zapisano polecenie:", identity, flush=True)
-        result = wait_reply(root, identity)
+        print("\nREQUEST:", identity, flush=True)
+        try:
+            result = wait_reply(
+                root, identity, progress=lambda row: print(waiting_label(row), flush=True)
+            )
+        except KeyboardInterrupt:
+            print("\nChat closed. Request remains queued/processing; mission continues.")
+            break
         if result["state"] == "completed":
             who = result["response"].get("responder", {})
             label = who.get("model", "controller")
             if who.get("delegated_while_master_busy"):
                 label += " - zastępca, V100 zajęty"
             elif who.get("accepted_master_on_cpu"):
                 label += " - zaakceptowany master na CPU"
-            print(f"{label}>", result["response"]["answer"])
-            print("Wykonane zmiany:", json.dumps(result["response"]["applied"], ensure_ascii=False))
+            print(f"\nMASTER [{label}]\n\n{result['response']['answer']}\n")
+            applied = result["response"]["applied"]
+            print(
+                "ACTION RECEIPTS:",
+                json.dumps(applied, ensure_ascii=False) if applied else "No control changes",
+            )
         else:
-            print(json.dumps({k: result[k] for k in ("id", "state", "error")}, ensure_ascii=False))
-            print("Odczyt: v100-continual chat-status", identity)
+            print(
+                waiting_label(result)
+                if result["state"] == "queued"
+                else f"FAILED: {result.get('error')}"
+            )
+            print("Read result: v100-continual chat-status", identity)
         if message is not None:
             break