mcpgawk 0.1.76__tar.gz → 0.1.78__tar.gz

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mcpgawk",
   "description": "Measure the MCP servers your agent calls, record the tool surface you approved, and refuse a changed tool until a person has looked. Local-first.",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "author": {
     "name": "Nativerse",
     "email": "hello@nativerse-ventures.com"
@@ -27,7 +27,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "mcpgawk==0.1.75",
+        "mcpgawk==0.1.77",
         "mcpgawk",
         "mcp"
       ]

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/.mcp.json

@@ -4,7 +4,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "mcpgawk==0.1.75",
+        "mcpgawk==0.1.77",
         "mcpgawk",
         "mcp"
       ]

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: mcpgawk
-Version: 0.1.76
+Version: 0.1.78
 Summary: One gateway in front of every MCP server your agents can reach — every call checked against a baseline you approved. Local-first: nothing leaves your machine.
 Project-URL: Homepage, https://mcp.gawk.dev
 Project-URL: Documentation, https://mcp.gawk.dev/docs

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mcpgawk"
-version = "0.1.76"
+version = "0.1.78"
 description = "One gateway in front of every MCP server your agents can reach — every call checked against a baseline you approved. Local-first: nothing leaves your machine."
 readme = "README.md"
 requires-python = ">=3.10"

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/server.json

@@ -8,12 +8,12 @@
     "url": "https://github.com/gawk-dev/mcpgawk",
     "source": "github"
   },
-  "version": "0.1.76",
+  "version": "0.1.78",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "mcpgawk",
-      "version": "0.1.76",
+      "version": "0.1.78",
       "runtimeHint": "uvx",
       "packageArguments": [
         {

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/src/mcpgawk/cli.py

@@ -1308,7 +1308,7 @@ def _approve(args) -> int:
                 print("Nothing to compare — the approval store is unreadable, so whether anything "
                       "changed is UNKNOWN. See the warning above.")
                 return 4   # INCOMPLETE: ran but could not finish. 1 means findings; this is neither.
-            print("Nothing to approve — every tracked server matches its approved baseline.")
+            print("Nothing to approve — every tracked server matches its baseline.")
             return 0
         print(f"{len(waiting)} server(s) changed since their baseline:\n")
         for key in waiting:

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/src/mcpgawk/decide.py

@@ -214,7 +214,7 @@ def render_page(items: list[dict[str, Any]], token: str, note: str = "",
                          f'changed or stopped answering is not a server that matches. '
                          f'See <code>mcpgawk monitor status</code>.</p>')
         body = ('<div class="done"><h1>Nothing is waiting on you.</h1>'
-                '<p>Every server with an approved baseline still matches it. '
+                '<p>Every server with a baseline still matches it. '
                 'This page opens when that stops being true.</p>'
                 + "".join(notes) + '</div>')
     else:

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/src/mcpgawk/history.py

@@ -1249,6 +1249,30 @@ def changed_head(origin: "str | None", when: "str | None") -> str:
             if when else "changed since its baseline; who approved it is not on record")
 
 
+def at_baseline_words(origins: "list[str | None]", *, plural: bool = False) -> str:
+    """THE words after "N server(s)" for records sitting at their baseline, from `baseline_origin`:
+    "at an approved baseline" only when a person stands behind every one (`vouched`); "at a
+    baseline with no person's approval on record" when none does; the split when mixed. The bare run's Protected
+    line, `status`'s EXPECTED BEHAVIOUR count and the panel's See step print this one string
+    (2026-10-09: all three said "at an approved baseline" of first-sighting records). An empty
+    set describes nothing and keeps the plain words."""
+    if not origins or vouched(origins):
+        return "at their approved baseline" if plural else "at an approved baseline"
+    # Not vouched: a first sighting (nobody), an unattended approval (no person present) or a
+    # record older than the markers (not on record). One phrase that is true of all three and
+    # asserts neither "you approved" nor "nobody did" — the same line `changed_head` walks.
+    n_v = sum(1 for o in origins if o in VOUCHED_ORIGINS)
+    if n_v == 0:
+        return "at a baseline with no person's approval on record"
+    return (f"at a baseline — {n_v} you approved, {len(origins) - n_v} with no person's "
+            f"approval on record")
+
+
+def at_baseline_words_for(store: dict[str, Any], keys: "list[str]", *, plural: bool = False) -> str:
+    """`at_baseline_words` for stored servers."""
+    return at_baseline_words([baseline_origin(store, k) for k in keys], plural=plural)
+
+
 def changed_within(store: dict[str, Any], days: int = 7,
                    now: "float | None" = None) -> list[tuple[str, str]]:
     """Servers whose surface first MOVED from its approved pin within the last `days`, as

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/src/mcpgawk/panel.py

@@ -487,8 +487,8 @@ TIERS = (
                                   "or injected output"),
     # NOT "never watched": a server verify exercised but nobody approved lands here too (A,
     # 2026-10-05) — it was watched, and there was no approval to verify it against.
-    ("unverified", "Unverified", "not verified against anything you approved — absence of a "
-                                 "finding, not safety"),
+    ("unverified", "Unverified", "not verified against a baseline — absence of a finding, "
+                                 "not safety"),
     # OBSERVED IS NOT VERIFIED, AND SAYS SO IN ITS OWN NAME. A session-bound-auth server can never
     # be verified here: the login belongs to the client's live session and verify's own session
     # times out. `wrap` rides that authenticated pipe and watches the real calls — real evidence,
@@ -503,7 +503,8 @@ TIERS = (
     # `mcpgawk status` counts it); this tier also needs behaviour observed. One page read "1 at an
     # approved baseline" beside "At baseline 0" (walk, 2026-10-05): one word, two facts. The
     # tier's own name is now the pair of "Unverified".
-    ("baseline", "Verified", "matches what you approved, and behaviour was observed"),
+    # "its baseline", not "what you approved": the record may be a first sighting (2026-10-09).
+    ("baseline", "Verified", "matches its baseline, and behaviour was observed"),
 )
 
 
@@ -631,7 +632,7 @@ def policy_rows(d: dict[str, Any]) -> list[tuple[str, str, str, str]]:
     rows.append(("Detect and respond to change",
                  "drift is itemised per tool and blocks the server until a person decides; "
                  "verify reproduces behaviour in a sandbox",
-                 f"{len(moved)} server(s) first seen changed in the last 7 days · {pending} awaiting a "
+                 f"{len(moved)} server(s) moved off their baseline in the last 7 days · {pending} awaiting a "
                  f"decision · last verify "
                  f"{_local_stamp(d.get('verify_at')) if d.get('verify_at') else 'never'}",
                  "warn" if pending else "ok"))
@@ -1709,7 +1710,11 @@ def journey_steps(d: dict[str, Any]) -> list[dict[str, Any]]:
     # The rule `status` and the bare run count by: approved AND not pending. Counting every
     # approved record said "1 at an approved baseline" during drift, beside their 0 (2026-10-05).
     from .protect import at_approved_baseline
-    approved = len(at_approved_baseline({"servers": store}, d.get("pending") or []))
+    # The WHOLE store, not `{"servers": store}`: the origin rule reads the fleet record too, and
+    # a fleet-approved baseline wrapped without it reads as a first sighting (one-rule test).
+    _whole_store = d.get("store") or {"servers": store}
+    _covered = at_approved_baseline(_whole_store, d.get("pending") or [])
+    approved = len(_covered)
     clients = sorted({c for e in entries.values() if isinstance(e, dict)
                       for c in (e.get("_clients") or [])})
     signins = signin_asks(entries)      # ONE source — the briefing strip reads the same list
@@ -1773,7 +1778,11 @@ def journey_steps(d: dict[str, Any]) -> list[dict[str, Any]]:
     # Approvals are the free-tier spine and belong in the fact line of 'see', not a stage of
     # their own — the founder's flow is fleet → trust → gateway, not a checklist of features.
     if approved:
-        steps[0]["fact"] += f" · {approved} at an approved baseline"
+        # The words follow the records' origins (history's one rule): "approved" only when a
+        # person stands behind every one. Said "at an approved baseline" of first sightings
+        # (walk, 2026-10-09), beside /next's "nobody has approved this server yet".
+        from .history import at_baseline_words_for as _abw
+        steps[0]["fact"] += f" · {approved} {_abw(_whole_store, _covered)}"
     if calls:
         # SEEN, not "checked" — same defect as the Activity headline, second surface. `calls` here
         # is the raw recent-call list; whether the guard actually checked any of them is a
@@ -1982,7 +1991,7 @@ def _calls_chart(series: list[dict]) -> str:
             + "".join(parts) + '</svg><figcaption>'
             f'<span><i class="ok"></i>Checked and allowed ({tot["allowed"]:,})</span>'
             f'<span><i class="bad"></i>Blocked ({tot["blocked"]:,})</span>'
-            f'<span><i class="warn"></i>Not checked — no approved baseline ({tot["not_checked"]:,})</span>'
+            f'<span><i class="warn"></i>Not checked — no baseline ({tot["not_checked"]:,})</span>'
             f'<span class="dim">{_esc(first)} → {_esc(last)}, per UTC day</span></figcaption></figure>')
 
 
@@ -2055,6 +2064,18 @@ def _today_tiles(series: list[dict], unscannable: object, changed: int = 0,
             + '</div>')
 
 
+def _summary_from_series(series: list[dict], summary: dict | None = None) -> dict:
+    """The headline's numbers from the chart's own series: seen = total, checked = allow + deny,
+    deferred = not checked. Empty series → the summary as given (nothing to disagree with)."""
+    if not series:
+        return dict(summary or {})
+    out = dict(summary or {})
+    out["calls"] = sum(int(d.get("total") or 0) for d in series)
+    out["checked"] = sum(int(d.get("checked") or 0) for d in series)
+    out["deferred"] = sum(int(d.get("not_checked") or 0) for d in series)
+    return out
+
+
 def _activity_headline(summary: object) -> str:
     """seen / checked / DECLINED — never a single number labelled "checked".
 
@@ -2080,7 +2101,7 @@ def _activity_headline(summary: object) -> str:
         # Written before the distinction existed: say so rather than infer a number.
         return (f"<b>{seen}</b> calls seen · <span class=\"warn\">how many were CHECKED is not "
                 f"recorded in this log</span>")
-    out = f"<b>{seen}</b> seen · <b>{checked}</b> checked against an approved baseline"
+    out = f"<b>{seen}</b> seen · <b>{checked}</b> checked against a baseline"
     if deferred:
         unsc = summary.get("deferred_unscannable") or 0
         scannable = max(deferred - unsc, 0)
@@ -3834,11 +3855,20 @@ def render(d: dict[str, Any], token: str = "", action: dict | None = None,
                 f'<td class="dim">{_esc(a.get("basis") or "")}</td><td>{why_cell}</td></tr>')
 
     act_summary = act if isinstance(act, dict) else {}
-    span_first = all_acts[-1].get("when") if all_acts else None
-    span_last = all_acts[0].get("when") if all_acts else None
+    # ONE WINDOW. spool.summarise() counts the last 5,000 rows; the chart under this line counts
+    # 14 days of up to 200,000. On the founder's machine the header read "4729 seen · 167
+    # checked" over "2026-10-01 → 2026-10-08" above a chart reading 87 checked, 3,510 not, over
+    # 09-26 → 10-09, with Today's tiles a third set (2026-10-09). The header now sums the
+    # chart's series, so the three cannot disagree; the one key the series lacks (which of the
+    # declined went to a browser host) is kept from summarise.
+    act_summary = _summary_from_series(_calls_series, act_summary)
+    span_first = (_calls_series[0]["day"] if _calls_series else
+                  (all_acts[-1].get("when") if all_acts else None))
+    span_last = (_calls_series[-1]["day"] if _calls_series else
+                 (all_acts[0].get("when") if all_acts else None))
     acts_notable = "".join(_act_row(a, expand_why=True) for a in notable) or \
         ('<tr><td colspan="6" class="dim">No call in this log was blocked, and nothing it '
-         'covers overstepped its approved baseline.' + monitor_gap_note(d) + '</td></tr>')
+         'covers overstepped its baseline.' + monitor_gap_note(d) + '</td></tr>')
     acts_full = "".join(_act_row(a) for a in all_acts[:500]) or \
         '<tr><td colspan="6" class="dim">Nothing recorded yet — use your agent once.</td></tr>'
     if _foreign_acts:
@@ -3900,15 +3930,18 @@ def render(d: dict[str, Any], token: str = "", action: dict | None = None,
             bits.append(f'<span class="nm">{_esc(t)}</span> <span class="dim">now declares more '
                         f'power than its baseline — {_esc(_what)}.</span>')
         for t in rep.added[:2]:
-            bits.append(f'<span class="nm">{_esc(t)}</span> <span class="dim">appeared after you '
-                        'approved this server. A tool that shows up later is how a malicious '
-                        'update arrives.</span>')
+            # "after you approved this server" under a row whose baseline nobody approved
+            # (Decisions tab, walk of 0.1.77): the anchor is the baseline, whoever set it.
+            bits.append(f'<span class="nm">{_esc(t)}</span> <span class="dim">was not in the '
+                        'baseline and appeared since. A tool that shows up later is how a '
+                        'malicious update arrives.</span>')
         for t in rep.removed[:1]:
             bits.append(f'<span class="nm">{_esc(t)}</span> <span class="dim">was removed.</span>')
         for t in plain_changed[:1]:
             bits.append(f'<span class="nm">{_esc(t)}</span> <span class="dim">changed its '
                         'description.</span>')
-        for t in rep.annotation_changed[:1]:
+        for t in [x for x in rep.annotation_changed if x not in (_esc_ or [])][:1]:
+            # An escalated key already has its sentence above; this is for a plain relabel.
             bits.append(f'<span class="nm">{_esc(t)}</span> <span class="dim">changed its safety '
                         'annotations — a tool relabelled itself.</span>')
         total = (len(rep.hostile) + len(rep.added) + len(rep.removed) + len(plain_changed)
@@ -5521,11 +5554,11 @@ def role_evidence(d: dict[str, Any]) -> str:
     basis is a guess wearing a name."""
     roles = roles_from_baseline(d)
     if not roles:
-        return ("No approved baseline yet, so there is nothing to build roles from. Scan and "
+        return ("No baseline yet, so there is nothing to build roles from. Scan and "
                 "approve a server first — a role is a statement about tools we have seen.")
     reads = len([g for g in roles.get("admin", []) if g == "read"])
     writes = len([g for g in roles.get("admin", []) if g.startswith("write:")])
-    return (f"Built from your approved baselines: "
+    return (f"Built from your baselines: "
             f"{'read-only tools' if reads else 'no read-only tools'}, {writes} write/destructive "
             f"tool(s)"
             + (" · tools your servers left unannotated are granted only to admin"
@@ -7682,8 +7715,12 @@ def uncovered_reasons(d: dict[str, Any], by_server: dict[str, int] | None = None
     entries = d.get("entries") or {}
     store = d.get("store") or {}
     known = set()
-    for k in (store.get("servers") or {}):
+    for k, e in (store.get("servers") or {}).items():
         known.add(str(k).split(":", 1)[-1].split("#", 1)[0])
+        # The config name, not only the identity: youspot's record is `mcp:connect` (what the
+        # server calls itself) with alias "youspot" (what the config calls it), and this said
+        # "it has no baseline yet" about an approved server (Agents tab, 2026-10-09).
+        known.update(str(a) for a in ((e or {}).get("aliases") or []))
     out: list[dict[str, Any]] = []
     for name, n in (by_server or {}).items():
         entry = entries.get(name)
@@ -8821,13 +8858,17 @@ def next_queue(d: dict[str, Any], skip: set[str] | frozenset[str] = frozenset())
                           "status": str(v.get("status") or ""), "at": str(v.get("at") or "")})
     # 6 — approved servers with nothing re-checking them.
     mon = _dict_at(d, "monitor")
-    approved_n = sum(1 for _n, _e, k, _t in fleet if k and _h.approved(store, k))
+    approved_keys = [k for _n, _e, k, _t in fleet if k and _h.approved(store, k)]
+    approved_n = len(approved_keys)
     if approved_n and not mon.get("running"):
         alerts = [a for a in (mon.get("alerts") or []) if isinstance(a, dict) and a.get("state") == "pending"]
         last = max((str(x.get("last_check") or "") for x in (mon.get("servers") or [])
                     if isinstance(x, dict)), default="")
+        # "approved" is the baseline's origin, not the record's presence (2026-10-10): the words
+        # come from history.at_baseline_words, the one rule every count surface prints from.
         items.append({"kind": "unwatched", "key": "monitor", "name": "monitor",
-                      "approved": approved_n, "alerts": len(alerts), "last_check": last})
+                      "approved": approved_n, "alerts": len(alerts), "last_check": last,
+                      "words": _h.at_baseline_words_for(store, approved_keys, plural=True)})
     # 7 — agents whose calls pass with no check: a hook point not installed, or none at all.
     for client, label, state, n_servers, det in _agent_rows(d):
         if state != "on":
@@ -9420,9 +9461,11 @@ def render_next(d: dict[str, Any], token: str = "", action: dict | None = None,
             eyebrow = f'1 OF {_eyebrow_n} · COULD NOT VERIFY' + (f' · LAST TRY {_esc(_local_stamp(it["at"]))}' if it["at"] else '')
         elif it["kind"] == "unwatched":
             n_ap = it["approved"]
-            head = f'Nothing is re-checking your {n_ap} approved server{"s" if n_ap != 1 else ""}.'
-            sub = ('Monitoring is off. A server that changes after you approved it will not raise '
-                   'an alert until someone scans — the rug-pull case waits for a human to look.')
+            words = it.get("words") or "at a baseline"
+            head = f'Nothing is re-checking your {n_ap} server{"s" if n_ap != 1 else ""} {words}.'
+            sub = ('Monitoring is off. A server that changes after its baseline was recorded will '
+                   'not raise an alert until someone scans — the rug-pull case waits for a human '
+                   'to look.')
             evidence = ('<h2>State</h2><div class="ev"><div class="lbl">monitor not running</div>'
                         + (f'<div class="was"><b>last check</b> {_esc(_local_stamp(it["last_check"]))}</div>' if it["last_check"] else '<div class="was">no sweep recorded</div>')
                         + (f'<div class="was"><b>open alerts</b> {it["alerts"]}</div>' if it["alerts"] else '')

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/src/mcpgawk/protect.py

@@ -161,7 +161,8 @@ def protection_report(store: dict[str, Any], guard_line: str,
         out.append("    Accept it:       mcpgawk approve <name>")
         out.append("")
 
-    out.append(f"  Protected: {len(covered)} server(s) at their approved baseline.")
+    out.append(f"  Protected: {len(covered)} server(s) "
+               f"{history.at_baseline_words_for(store, covered, plural=True)}.")
     out.append(f"  {guard_line}")
 
     if appeared:

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/src/mcpgawk/status.py

@@ -101,6 +101,7 @@ def hook_health_by_client() -> dict[str, str]:
 
 def render(*, hook_health: dict[str, str], guard_path: "dict[str, Path] | Path | None",
            agents: dict[str, int], baseline_total: int, pending: list[str],
+           baseline_words: str | None = None,
            pending_keys: list[str] | None = None,
            behaviour_tools: int | None, enforce_available: bool,
            last_activity: str | None, activity: dict | None = None,
@@ -173,7 +174,8 @@ def render(*, hook_health: dict[str, str], guard_path: "dict[str, Path] | Path |
         out.append(f"      ⚠ could not read your approved baseline ({baseline_error}) — the "
                    f"number of approved servers is UNKNOWN, not zero.")
     else:
-        out.append(f"      {baseline_total} server(s) at an approved baseline (what they may expose)")
+        out.append(f"      {baseline_total} server(s) "
+                   f"{baseline_words or 'at a baseline'} (what they may expose)")
     if behavioural_unavailable:
         # B5 — never a silent fallback: the missing dependency is named BEFORE any name-only
         # posture is described, and no dead command (`mcpgawk verify` cannot run here) is offered.
@@ -252,7 +254,7 @@ def render(*, hook_health: dict[str, str], guard_path: "dict[str, Path] | Path |
             out.append("      how many were actually CHECKED is not recorded in this log "
                        "(written before the distinction existed)")
         else:
-            out.append(f"      {checked} actually checked against an approved baseline")
+            out.append(f"      {checked} actually checked against a baseline")
         if deferred:
             out.append(f"      ⚠ {deferred} call(s) NOT checked — the guard declined (no or stale "
                        f"baseline projection) and let them through. Run `mcpgawk scan`.")
@@ -328,12 +330,17 @@ def collect() -> dict:
         # approved — was counted here as "at an approved baseline" (walk, 2026-10-05). The panel's
         # policy row and protect's "Protected" count already asked this question.
         from .protect import at_approved_baseline
-        baseline_total = len(at_approved_baseline(store, pending_keys))
+        _covered = at_approved_baseline(store, pending_keys)
+        baseline_total = len(_covered)
+        # The words follow the records' origins — history's one rule, shared with the bare
+        # run's Protected line and the panel's See step (2026-10-09).
+        baseline_words = history.at_baseline_words_for(store, _covered)
         # Resolve to what the USER calls each server, not our internal identity key.
         pending = [history.display_name(store, k) for k in pending_keys]
         muted_total = history.muted_total(store)
     except Exception as exc:                       # noqa: BLE001
         pending, pending_keys, baseline_total, muted_total = [], [], 0, 0
+        baseline_words = None
         baseline_error = f"{type(exc).__name__}: {exc}"
         store = None
 
@@ -448,7 +455,8 @@ def collect() -> dict:
 
     return dict(hook_health=hook_health, guard_path=guard_path, agents=agents,
                   agents_error=agents_error,
-                  baseline_total=baseline_total, pending=pending, pending_keys=pending_keys,
+                  baseline_total=baseline_total, baseline_words=baseline_words,
+                  pending=pending, pending_keys=pending_keys,
                   baseline_error=baseline_error,
                   behaviour_tools=behaviour_tools, enforce_available=enforce_available,
                   last_activity=last_activity, activity=activity, muted_total=muted_total,

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/tests/test_first_run_0175.py

@@ -232,3 +232,51 @@ def test_a_set_aside_server_is_named_once_and_never_prompted_for(monkeypatch, ca
     cli._offer_batched_auth([_Row("robinhood")], types.SimpleNamespace(yes=False), {})
     out = capsys.readouterr()
     assert "These need credentials" not in out.out and "robinhood" in out.err
+
+
+# --- the walk of every panel tab on the founder's 0.1.75/0.1.76 fleet (2026-10-09, evening) ---------
+
+def test_the_agents_detail_knows_a_server_by_its_config_name():
+    """youspot's record is `mcp:connect` (what the server calls itself) with alias "youspot" (what
+    the config calls it). The Agents detail said "it has no baseline yet — a scan records one"
+    about an approved server."""
+    d = {"entries": {"youspot": {"url": "https://y.test/mcp"}, "fresh": {"url": "https://f.test/mcp"}},
+         "store": {"servers": {"mcp:connect": {"aliases": ["youspot"], "approved": {"items": {}}}}}}
+    out = {r["server"]: r for r in panel.uncovered_reasons(d, {"youspot": 232, "fresh": 3})}
+    assert out["youspot"]["reason"] == "stale", out["youspot"]
+    assert out["fresh"]["reason"] == "unscanned"
+
+
+def test_the_activity_header_counts_the_charts_own_series(monkeypatch, tmp_path):
+    """Header "4729 seen · 167 checked · 2026-10-01 → 10-08" over a chart reading 87 checked,
+    3,510 not checked, 09-26 → 10-09: two windows and two row limits on one page."""
+    today = _today(monkeypatch, tmp_path, entries={"p": {"command": "npx p"}},
+                   calls=[("allow", "p")] * 3 + [("defer", "q")] * 5 + [("deny", "p")])
+    # One row OUTSIDE the chart's 14-day window: summarise() counts it (lifetime over the rows
+    # it reads), the chart does not. The header must follow the chart.
+    import json, os
+    from datetime import datetime, timedelta, timezone
+    old = (datetime.now(timezone.utc) - timedelta(days=20)).strftime("%Y-%m-%dT%H:%M:%SZ")
+    with open(os.environ["MCPGAWK_SPOOL"], "a") as f:
+        f.write(json.dumps({"ts": old, "decision": "allow", "server": "p", "tool": "t"}) + "\n")
+    page = panel.render({"entries": {"p": {"command": "npx p"}}, "store": {"servers": {}}, "pending": [],
+                         "activity": {"calls": 999, "checked": 1, "deferred": 998}, "recent_calls": [],
+                         "findings": [], "unscannable": [], "monitor": {}, "verify_at": ""}, token="t")
+    head = re.search(r"<b>(\d+)</b> seen · <b>(\d+)</b> checked against a baseline"
+                     r"(?: · <span class=\"warn\"><b>(\d+)</b> NOT checked)?", page)
+    assert head, "no activity headline"
+    seen, checked, deferred = int(head.group(1)), int(head.group(2)), int(head.group(3) or 0)
+    allowed = int(re.search(r"Checked and allowed \((\d+)\)", page).group(1))
+    blocked = int(re.search(r"Blocked \((\d+)\)", page).group(1))
+    not_checked = int(re.search(r"Not checked — no baseline \(([\d,]+)\)", page).group(1).replace(",", ""))
+    assert (seen, checked, deferred) == (allowed + blocked + not_checked, allowed + blocked, not_checked), \
+        (seen, checked, deferred, allowed, blocked, not_checked)
+    assert (checked, deferred) == (4, 5)                      # not summarise's 1 / 998
+
+
+def test_summary_from_series_is_the_chart_arithmetic():
+    series = [{"day": "2026-10-08", "total": 10, "checked": 2, "blocked": 1, "not_checked": 8},
+              {"day": "2026-10-09", "total": 5, "checked": 1, "blocked": 0, "not_checked": 4}]
+    out = panel._summary_from_series(series, {"deferred_unscannable": 7, "calls": 999})
+    assert (out["calls"], out["checked"], out["deferred"], out["deferred_unscannable"]) == (15, 3, 12, 7)
+    assert panel._summary_from_series([], {"calls": 1}) == {"calls": 1}

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/tests/test_one_rule_every_surface.py

@@ -87,6 +87,23 @@ def test_the_next_screens_evidence_block_follows_the_same_split():
     assert "rug-pull signature" not in esc, esc
     assert "openWorldHint" in esc, "the /next evidence must say what grew"
     assert esc.count("tool.t —") == 2, esc       # description row + ONE annotation row, not two
+
+
+def test_the_decisions_tab_names_an_escalated_key_once_and_never_as_an_injection():
+    """Walk of 0.1.77: the Decisions tab listed read_notes as "now declares more power" AND as
+    "changed its safety annotations — a tool relabelled itself", and new_tool as "appeared after
+    you approved this server" under a baseline nobody approved."""
+    from mcpgawk import history, panel
+    store = _store_for("first-sighting")
+    store["servers"]["mcp:s"]["history"][-1]["annotations"] = {"tool.read_note": {"openWorldHint": True}}
+    store["servers"]["mcp:s"]["approved"]["annotations"] = {"tool.read_note": {"openWorldHint": False}}
+    d = {"store": store, "entries": {}, "monitor": {}, "verify_at": "", "pending": ["mcp:s"],
+         "activity": {}, "recent_calls": [], "findings": [], "unscannable": []}
+    pane = _pane(panel.render(d, token="T"), "p3")
+    assert "you approved" not in pane, pane
+    assert "rug-pull signature" not in pane, pane
+    assert pane.count("tool.read_note</span>") == 1, pane
+    assert "was not in the baseline and appeared since" in pane, pane
     inj = panel._next_diff(_injected_only())
     assert "rug-pull signature" in inj, inj
 
@@ -160,6 +177,11 @@ def _store_for(origin: str) -> dict:
     return {**store_extras, "servers": {"mcp:s": entry}}
 
 
+def _pane(page: str, pane_id: str) -> str:
+    start = page.index(f'id="{pane_id}"')
+    return page[start:page.index("</section>", start)]
+
+
 def _surfaces(origin: str) -> dict[str, str]:
     store = _store_for(origin)
     key = "mcp:s"
@@ -176,6 +198,8 @@ def _surfaces(origin: str) -> dict[str, str]:
         "since words": history.since_words([report.baseline_origin]),
         "panel next": re.search(r"<h1>(.*?)</h1>", panel.render_next(d, token="T"), re.S).group(1),
         "panel next evidence": panel._next_diff(report),
+        "decisions tab": _pane(panel.render({**d, "pending": [key], "activity": {}, "recent_calls": [],
+                                             "findings": [], "unscannable": []}, token="T"), "p3"),
         "decide page": decide.render_page(decide.pending_decisions(store), "T"),
         "decide evidence": decide._diff_block(report),
     }
@@ -231,3 +255,67 @@ def test_a_config_name_beats_an_adhoc_target_whatever_the_alias_order():
     # Only ad-hoc targets: the asserted name (unchanged rule).
     store = {"servers": {"mcp:tiny": {"aliases": ["https://t.test/mcp"]}}}
     assert history.display_name(store, "mcp:tiny") == "tiny"
+
+
+# --- "N at an approved baseline": the steady-state words follow the same origin rule ---------- #
+# The bare run's Protected line, `status`'s EXPECTED BEHAVIOUR count and the panel's See step all
+# said "at an approved baseline" of first-sighting records (walk, 2026-10-09) while /next said
+# "nobody has approved this server yet" of the same store. One helper, three surfaces.
+
+from mcpgawk import status
+
+
+def _store_at_baseline(origin: str) -> dict:
+    """`_store_for` with no drift: the latest sighting IS the baseline."""
+    extras, store_extras, at = ORIGINS[origin]
+    entry = {"aliases": ["s"], "approved": _sight("p1", at), "history": [_sight("p1", at)], **extras}
+    return {**store_extras, "servers": {"mcp:s": entry}}
+
+
+def _steady_surfaces(origin: str) -> dict[str, str]:
+    store = _store_at_baseline(origin)
+    st = dict(hook_health={}, guard_path=None, agents={}, baseline_total=1,
+              baseline_words=history.at_baseline_words_for(store, ["mcp:s"]),
+              pending=[], pending_keys=[], behaviour_tools=None, enforce_available=False,
+              last_activity=None)
+    d = {"store": store, "entries": {"s": {"url": "https://s.test/mcp", "_clients": ["cursor"]}},
+         "monitor": {}, "verify_at": "", "pending": [], "appeared": {},
+         "gateway": {}, "activity": {}, "recent_calls": [], "findings": [], "unscannable": []}
+    see = panel.journey_steps(d)[0]["fact"]
+    # /next, the unwatched card: "Nothing is re-checking your N server(s) …" (walk of the built
+    # 0.1.78 wheel, 2026-10-10: it said "2 approved servers" over a first-sighting record).
+    [unwatched] = [it for it in panel.next_queue(d) if it["kind"] == "unwatched"]
+    nxt = panel.render_next(d, token="T")
+    head = nxt[nxt.index("Nothing is re-checking"):]
+    head = head[:head.index("</")]
+    assert str(unwatched["approved"]) in head, head
+    return {
+        "protect report": protect.protection_report(store, "guard on", unchecked=[]),
+        "status count": status.render(**st),
+        "panel see step": see,
+        "next unwatched": head,
+    }
+
+
+@pytest.mark.parametrize("origin", sorted(ORIGINS))
+def test_every_count_surface_agrees_on_whether_the_baseline_was_approved(origin):
+    out = _steady_surfaces(origin)
+    for surface, text in out.items():
+        low = text.lower()
+        assert "1 " in text or "protected:" in low, (surface, text[:200])
+        says_approved = "approved baseline" in low or "you approved" in low
+        if origin in SAYS_A_PERSON_APPROVED:
+            assert says_approved, (origin, surface, text[:300])
+        else:
+            assert not says_approved, (origin, surface, text[:300])
+            assert "no person's approval on record" in low, (origin, surface, text[:300])
+            # Neither "nobody approved" nor "you approved" is asserted of an unattended or
+            # unknown record; the first-sighting cases are covered by the drift test above.
+            assert "nobody" not in low and "you have not" not in low, (origin, surface, text[:300])
+
+
+def test_a_mixed_fleet_states_the_split():
+    assert history.at_baseline_words(["approve", "first-sighting", None]) == \
+        "at a baseline — 1 you approved, 2 with no person's approval on record"
+    assert history.at_baseline_words(["approve", "fleet"], plural=True) == "at their approved baseline"
+    assert history.at_baseline_words([]) == "at an approved baseline"

{mcpgawk-0.1.76 → mcpgawk-0.1.78}/tests/test_panel_next.py

@@ -274,8 +274,10 @@ def test_could_not_verify_quotes_the_engine_and_offers_a_rerun(monkeypatch):
 
 def test_unwatched_names_the_count_and_offers_both_starts(monkeypatch):
     html = _one(monkeypatch, {"kind": "unwatched", "key": "monitor", "name": "monitor",
-                              "approved": 9, "alerts": 6, "last_check": "2026-09-05T01:37:58"})
-    assert "Nothing is re-checking your 9 approved servers." in html
+                              "approved": 9, "alerts": 6, "last_check": "2026-09-05T01:37:58",
+                              "words": "at their approved baseline"})
+    # The words come from history.at_baseline_words (origin, not record presence; 2026-10-10).
+    assert "Nothing is re-checking your 9 servers at their approved baseline." in html
     assert 'value="monitor-start"' in html and 'value="monitor-start-local"' in html
     assert html.count("btn primary") == 1, "one accent action"
     assert "<b>open alerts</b> 6" in html