feat(scoring): transport-agnostic CI grounding — WebFetch, skills, CLI (#34)

Context Intelligence only counted MCP knowledge calls as grounding,
missing WebFetch/WebSearch (98% knowledge validated), knowledge skills
(deep-research, sdd-explore, claude-api, graphify), and CLI tools
(codegraph explore, gh issue/pr view). This made CI invisible for
users who consult context via non-MCP channels.

Arm grounding from 6 channels: MCP knowledge (existing), MCP
project/data/design explore-class (existing), WebFetch/WebSearch
with localhost exclusion, knowledge skills via Skill tool and
attributionSkill, knowledge Agent subagent_types, and CLI knowledge
commands via Bash. All idempotent per-session — no double counting.

Author: mirland

gnomon/cli/accumulator.py

@@ -27,8 +27,9 @@
 from gnomon.config import parse_ts, line_count, strip_injections
 from gnomon.taxonomy import (
     SCHEDULE_TOOLS, ASK_TOOLS, PLAN_SIGNAL_TOOLS, PLAN_SKILL_NEEDLES,
+    KNOWLEDGE_SKILL_NEEDLES,
     classify_tool, classify_mcp_subcategory, CI_CONTEXT_SUBCATS,
-    bash_writes_file, bash_runs_tests, _extract_clis,
+    bash_writes_file, bash_runs_tests, bash_runs_knowledge, _extract_clis,
     _is_compounding_path, _SKILL_MD_RX,
 )
 from gnomon.sources.discovery import _AGENT_UNSUPPORTED_SOURCES
@@ -47,6 +48,15 @@
 BURST_GAP_S = 1800                # a gap > 30 min ends a contiguous work "run"
 DOW = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
 
+_KNOWLEDGE_NATIVE_TOOLS = frozenset({"WebFetch", "WebSearch"})
+
+
+def _is_local_url(url):
+    if not url:
+        return False
+    low = url.lower()
+    return any(h in low for h in ("localhost", "127.0.0.1", "0.0.0.0", "[::1]"))
+
 
 def _zero_tok():
     return {"input": 0, "output": 0, "cache_read": 0, "cache_creation": 0}
@@ -218,6 +228,10 @@ def _is_plan_skill(name):
         sl = str(name).lower()
         return any(nd in sl for nd in PLAN_SKILL_NEEDLES)
 
+    def _is_knowledge_skill(self, name):
+        low = (name or "").lower()
+        return any(n in low for n in KNOWLEDGE_SKILL_NEEDLES)
+
     def _mark_plan_session(self, sid, mkey):
         """Record that session `sid` (in month `mkey`) contained a planning signal.
         Idempotent per session — repeated signals in one session count once."""
@@ -433,6 +447,8 @@ def observe(self, ev, since_dt, until_dt):
                     self.month_skill_counter[mkey][ev["attributionSkill"]] += 1
                 if self._is_plan_skill(ev["attributionSkill"]):
                     self._mark_plan_session(sid, mkey)
+                if self._is_knowledge_skill(ev["attributionSkill"]):
+                    self._pending_knowledge_grounding[sid] = True
             content = msg.get("content")
             if isinstance(content, list):
                 for b in content:
@@ -484,6 +500,11 @@ def observe(self, ev, since_dt, until_dt):
                         else:
                             self.native_calls += 1
 
+                        if sid and name in _KNOWLEDGE_NATIVE_TOOLS:
+                            url = inp.get("url", "")
+                            if not _is_local_url(url):
+                                self._pending_knowledge_grounding[sid] = True
+
                         # a tool use after a pending error = recovery
                         if sid and self._pending_error.get(sid):
                             self.recovered_errors += 1
@@ -500,6 +521,8 @@ def observe(self, ev, since_dt, until_dt):
                                 # a planning Skill also marks this a planning session
                                 if self._is_plan_skill(s):
                                     self._mark_plan_session(sid, mkey)
+                                if self._is_knowledge_skill(s):
+                                    self._pending_knowledge_grounding[sid] = True
                         # Plan-ceremony signal: mark this SESSION as a planning session.
                         # PLAN_SIGNAL_TOOLS normalizes across sources (EnterPlanMode = Cursor
                         # create_plan; ExitPlanMode = Claude Code native plan mode, shift+tab ->
@@ -512,10 +535,10 @@ def observe(self, ev, since_dt, until_dt):
                         if name == "Agent":
                             st = inp.get("subagent_type", "general-purpose")
                             self.subagent_counter[st] += 1
-                            # A planning subagent (SDD planning phases, the built-in Plan
-                            # agent, *-planner types) also marks this a planning session.
                             if self._is_plan_skill(st):
                                 self._mark_plan_session(sid, mkey)
+                            if self._is_knowledge_skill(st):
+                                self._pending_knowledge_grounding[sid] = True
                             if mkey:
                                 self.month_subagent_counter[mkey][st] += 1
                             if sid:
@@ -623,6 +646,8 @@ def observe(self, ev, since_dt, until_dt):
                                         self.month_skill_counter[mkey][_sm.group(1)] += 1
                                     if self._is_plan_skill(_sm.group(1)):
                                         self._mark_plan_session(sid, mkey)
+                                    if self._is_knowledge_skill(_sm.group(1)):
+                                        self._pending_knowledge_grounding[sid] = True
                             if bash_writes_file(cmd):
                                 self.bash_write_calls += 1
                                 _bash_nl = cmd.count("\n")
@@ -634,6 +659,8 @@ def observe(self, ev, since_dt, until_dt):
                                 self.shell_test_runs += 1
                                 if mkey:
                                     self.month_shell_test_runs[mkey] += 1
+                            if bash_runs_knowledge(cmd):
+                                self._pending_knowledge_grounding[sid] = True
                             if "git commit" in cmd:
                                 self.git_commits += 1
                                 # flush iteration-depth run for this session

gnomon/taxonomy.py

@@ -27,6 +27,20 @@
 if _extra_plan_needles:
     PLAN_SKILL_NEEDLES = PLAN_SKILL_NEEDLES + tuple(
         n.strip().lower() for n in _extra_plan_needles.split(",") if n.strip())
+KNOWLEDGE_SKILL_NEEDLES = (
+    "deep-research",
+    "explore",
+    "claude-api",
+    "graphify",
+    "codegraph",
+    "find-docs",
+    "find-skills",
+    "explain-code",
+)
+_extra_knowledge_needles = os.environ.get("GNOMON_KNOWLEDGE_SKILL_NEEDLES", "")
+if _extra_knowledge_needles:
+    KNOWLEDGE_SKILL_NEEDLES = KNOWLEDGE_SKILL_NEEDLES + tuple(
+        n.strip().lower() for n in _extra_knowledge_needles.split(",") if n.strip())
 SCHEDULE_TOOLS = {"ScheduleWakeup", "CronCreate", "CronDelete", "CronList",
                   "RemoteTrigger", "PushNotification", "Monitor"}
 SKILL_TOOLS = {"Skill"}
@@ -182,6 +196,20 @@ def bash_runs_tests(cmd):
     return bool(_SHELL_TEST_RE.search(cmd or ""))
 
 
+_SHELL_KNOWLEDGE_RE = re.compile(
+    r'(?:^|[\s;&|(/])('
+    r'codegraph\s+(?:explore|search|query)'
+    r'|graphify'
+    r'|gh\s+(?:issue|pr)\s+view'
+    r')(?=$|[\s;&|):])',
+    re.IGNORECASE,
+)
+
+
+def bash_runs_knowledge(cmd):
+    return bool(_SHELL_KNOWLEDGE_RE.search(cmd or ""))
+
+
 def _extract_clis(command):
     """Return the known-CLI heads invoked in a shell command (one per &&/|/;-separated part)."""
     found = []