D4 stage 2: fold gemini_cli, tabnine, junie, grok onto the flat_decision engine

The four F2 modules are deleted; adapters.get() binds each to the D3
engine over its data/vendors entry, and bundle() composes engine + inlined
VENDOR literal for them. Golden fixtures byte-for-byte unchanged; the
12-agent bundler subprocess replay is green. The tabnine source-grep
vocabulary test is retired per design §5, its intent already re-homed as
test_vocabulary_basis_is_unverified_only_for_tabnine. junie's
PermissionRequest alias gate joins _EXTRA_GATE_NAMES; the transitional
gemini fields override in tools/recount is removed now that the entry is
the source.

Signed-off-by: Open Coder AI <250249270+open-coder-ai@users.noreply.github.com>

Author: jothimani-rajendran

CHANGELOG.md

@@ -30,6 +30,32 @@ versioning: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
   chains (demonstrated, not merely asserted).
 
 ### Changed
+- **The four `flat_decision` adapters are folded onto the same engine**
+  (`docs/design/dialect-families.md` D4). `gemini_cli`, `tabnine`, `junie` and `grok` are
+  no longer hand-written modules: the D3 engine executes their `data/vendors/<agent>.json`
+  entries, which now carry the G1 renderer data (verdict `words`, `degrade_notes` verbatim
+  from the deleted adapters, `reason_defaults`). The golden wire fixtures pass
+  **byte-for-byte unchanged**. The devices F2 needed are all word/grammar-table
+  extensions, each an opt-in schema field: an escalate word path in the G1 renderer, the
+  `hook_specific_tool_input` (gemini) and `top_level_updated_input` (junie) transform
+  bodies, template degrade notes filling (reason, wire event) slots (gemini's
+  ask-degradation), per-gate reason defaults and allow-silence and allow-body context
+  (junie's Stop/`additionalContext`), a reverse-map fallback for payloads carrying no wire
+  event name (tabnine's hand-built events), a `tool_input` envelope chain (grok's
+  `toolInput`), write-gated content (gemini), and literal hook-entry extras (tabnine's
+  `name`). junie's `PermissionRequest` alias gate is recounted explicitly via
+  `_EXTRA_GATE_NAMES`, same as devin's. `bundle()` now composes engine + inlined `VENDOR`
+  literal for these four too (measured: gemini_cli 690, tabnine 664, junie 664, grok 664
+  lines, from 458/409/429/439 — real numbers in the design doc §7). Two respond()-direct
+  behaviours the events table cannot express did not survive the fold: tabnine no longer
+  answers the undocumented `BeforeModel`/`AfterModel` wire names (they map to no canonical
+  event, and the dispatcher never reached them), and gemini_cli no longer honours a
+  rewrite at gates whose recounted capability is deny-only — both unreachable through
+  `handle()`, so the wire through the dispatcher is unchanged.
+  `test_the_unverified_vocabulary_is_still_only_tabnine` is retired exactly as §5's table
+  prescribed; its intent lives on as
+  `test_vendor_config.py::test_vocabulary_basis_is_unverified_only_for_tabnine`, a config
+  derivation instead of a source grep.
 - **Four `hook_json` adapters are now one engine plus their vendor config entries**
   (`docs/design/dialect-families.md` D3). `claude_code`, `codex_cli`, `kimi_code` and
   `devin` are no longer hand-written modules: `adapters/_hook_json.py` (marker claims,

docs/design/dialect-families.md

@@ -321,6 +321,17 @@ first, D3/D4 swap cleanly — they share only D1+D2.
   §4 payoff side held: the four deleted adapter modules were 624 lines; the engine that
   replaces them (`_hook_json` + `_hook_entry` + `_probes` + `_family`) is ~390 shared
   across the family.
+- **[v]** D4's F2 numbers, measured at its base (main `b9ae0a8`, where the pre-fold
+  bundles stood at gemini_cli 458 / tabnine 409 / junie 429 / grok 439): gemini_cli 690,
+  tabnine 664, junie 664, grok 664 — +51% to +62%, above both the §4 estimate (470–500)
+  and D3's +32–44%. The overshoot is composition, not dialect: an engine bundle inlines
+  the whole shared engine, G2 and the F1-only devices included — the trade D3 already
+  made, and the bundle-composition wave (D6) owns any trimming. The source-tree payoff
+  held again: the four deleted modules were 465 lines, replaced by no new engine module
+  at all — the D3 engine absorbed F2 with ~40 lines of word/grammar-table devices
+  (escalate word path, two transform-body variants, template notes, per-gate reason
+  defaults, allow-body context/silence, a reverse-map wire fallback, a tool-input
+  envelope chain, write-gated content, literal hook-entry extras).
 - **[v]** (was [h]) The `reject_probes: ["looks_like_claude_code"]` device (named engine
   predicates referenced from config) is the narrowest crack in the code/config line;
   if D2 finds more than ~3 named probes are needed, that is evidence the line is drawn

src/agentseam/adapters/__init__.py

@@ -6,27 +6,19 @@
 from . import (
     antigravity,
     cursor,
-    gemini_cli,
-    grok,
-    junie,
-    tabnine,
     vscode_copilot,
     windsurf,
 )
 from ._family import bind
 
-#: hook_json vendors driven by engine + data/vendors entry (dialect-families.md D3);
+#: hook_json (D3) and flat_decision (D4) vendors driven by engine + data/vendors entry;
 #: vscode_copilot stays a dialect module -- its three-path claims() and memory-tool
 #: branching are beyond what the flat config may carry (§3.1).
-_CONFIG_DRIVEN = ("claude_code", "codex_cli", "devin", "kimi_code")
+_CONFIG_DRIVEN = ("claude_code", "codex_cli", "devin", "gemini_cli", "grok", "junie", "kimi_code", "tabnine")
 
 ADAPTERS = {
     antigravity.AGENT: antigravity,
     cursor.AGENT: cursor,
-    gemini_cli.AGENT: gemini_cli,
-    grok.AGENT: grok,
-    junie.AGENT: junie,
-    tabnine.AGENT: tabnine,
     vscode_copilot.AGENT: vscode_copilot,
     windsurf.AGENT: windsurf,
 }

src/agentseam/adapters/_hook_json.py

@@ -1,4 +1,4 @@
-"""The F1 `hook_json` family engine: claims/parse/respond driven by a vendor config entry.
+"""The F1 `hook_json` / F2 `flat_decision` engine: claims/parse/respond driven by a vendor config entry.
 
 Every function takes the vendor's `data/vendors/<agent>.json` entry as its first argument;
 `_family.bind()` closes them over one entry, and a bundle inlines this module next to a
@@ -211,7 +211,9 @@ def _g1(v, gate, decision, wire, name):
                 if decision.reason:
                     out["reason"] = decision.reason
                 return _json.dumps(out), 0
-            return _json.dumps({"hookSpecificOutput": {"hookEventName": name, "updatedInput": decision.updated_input}}), 0
+            return _json.dumps(
+                {"hookSpecificOutput": {"hookEventName": name, "updatedInput": decision.updated_input}}
+            ), 0
     if decision.outcome == ESCALATE and gate["honours_escalate"] and "escalate" in words:
         reason = decision.reason or _default_for(v, decision, True, wire)
         return _json.dumps({"decision": words["escalate"], "reason": reason}), 0