@vibelord/lanes 1.3.0 → 1.5.1

package/payload/lanes/container/hooks/grok-cli-hooks.json

@@ -0,0 +1,8 @@
+{"hooks": {
+  "UserPromptSubmit": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event UserPromptSubmit --harness grok-cli", "timeout": 2}]}],
+  "PreToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PreToolUse --harness grok-cli", "timeout": 2}]}],
+  "PostToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PostToolUse --harness grok-cli", "timeout": 2}]}],
+  "Stop": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_input --event Stop --harness grok-cli", "timeout": 2}]}],
+  "StopFailure": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal errored --event StopFailure --harness grok-cli", "timeout": 2}]}],
+  "SessionEnd": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal shell --event SessionEnd --harness grok-cli", "timeout": 2}]}]
+}}

package/payload/lanes/container/hooks/grok-hooks.json

@@ -0,0 +1,12 @@
+{"hooks": {
+  "UserPromptSubmit": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event UserPromptSubmit --harness grok", "timeout": 2}]}],
+  "PreToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PreToolUse --harness grok", "timeout": 2}]}],
+  "PostToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PostToolUse --harness grok", "timeout": 2}]}],
+  "Notification": [{"matcher": "permission_prompt", "hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_approval --event Notification --harness grok", "timeout": 2}]},
+                  {"matcher": "idle_prompt", "hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_input --event Notification --harness grok", "timeout": 2}]}],
+  "Stop": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_input --event Stop --harness grok", "timeout": 2}]}],
+  "StopFailure": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal errored --event StopFailure --harness grok", "timeout": 2}]}],
+  "StopCancelled": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_input --event StopCancelled --harness grok", "timeout": 2}]}],
+  "SessionStart": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal idle --event SessionStart --harness grok", "timeout": 2}]}],
+  "SessionEnd": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal shell --event SessionEnd --harness grok", "timeout": 2}]}]
+}}

package/payload/lanes/container/hooks/kimi-hooks.toml

@@ -0,0 +1,49 @@
+# >>> lanes hooks >>>
+# Kimi Code -> ~/.lz/bin/lane-signal (`lanes hooks install --agent kimi` merges this block into
+# ~/.kimi-code/config.toml between these two marker lines; nothing outside them is rewritten). Kimi Code
+# runs each command through a shell with the hook JSON (session_id, snake_case) on stdin.
+[[hooks]]
+event = "PreToolUse"
+command = "~/.lz/bin/lane-signal working --event PreToolUse --harness kimi"
+timeout = 2
+[[hooks]]
+event = "PostToolUse"
+command = "~/.lz/bin/lane-signal working --event PostToolUse --harness kimi"
+timeout = 2
+[[hooks]]
+event = "PermissionRequest"
+command = "~/.lz/bin/lane-signal needs_approval --event PermissionRequest --harness kimi"
+timeout = 2
+[[hooks]]
+event = "PermissionResult"
+command = "~/.lz/bin/lane-signal working --event PermissionResult --harness kimi"
+timeout = 2
+[[hooks]]
+event = "UserPromptSubmit"
+command = "~/.lz/bin/lane-signal working --event UserPromptSubmit --harness kimi"
+timeout = 2
+[[hooks]]
+event = "TurnStarted"
+command = "~/.lz/bin/lane-signal working --event TurnStarted --harness kimi"
+timeout = 2
+[[hooks]]
+event = "Stop"
+command = "~/.lz/bin/lane-signal needs_input --event Stop --harness kimi"
+timeout = 2
+[[hooks]]
+event = "StopFailure"
+command = "~/.lz/bin/lane-signal errored --event StopFailure --harness kimi"
+timeout = 2
+[[hooks]]
+event = "Interrupt"
+command = "~/.lz/bin/lane-signal needs_input --event Interrupt --harness kimi"
+timeout = 2
+[[hooks]]
+event = "SessionStart"
+command = "~/.lz/bin/lane-signal idle --event SessionStart --harness kimi"
+timeout = 2
+[[hooks]]
+event = "SessionEnd"
+command = "~/.lz/bin/lane-signal shell --event SessionEnd --harness kimi"
+timeout = 2
+# <<< lanes hooks <<<

package/payload/lanes/container/lane

@@ -29,10 +29,15 @@ a `holder: tmux` lane through its exact socket and session; any other id is a zm
                               once) and prints {id, …, picked_up_by, expected_within_s} as JSON; the host's lanes-docsd
                               takes it within ~5 s and writes <id>.receipt.json beside it (kind from the extension when
                               --kind is left out; the file must be under /home/coder, at most 32 MiB)
-  lane mcp install [--agent claude|codex|all] [--write]
+  lane mcp install [--agent claude|codex|kimi|grok|grok-cli|all] [--write]
                               add the Lanes MCP server (~/.lz/bin/lane-mcp) to ~/.claude.json (mcpServers.lanes) and
                               ~/.codex/config.toml ([mcp_servers.lanes], with env_vars passing LANE_ID, LANE_WS, TMUX
-                              and TMUX_PANE: Codex clears a server's environment): prints the diff; --write applies
+                              and TMUX_PANE: Codex clears a server's environment), and — where that harness's home is
+                              a directory here, or when named — ~/.kimi-code/mcp.json (mcpServers.lanes),
+                              ~/.grok-build/config.toml (Grok Build's GROK_HOME: a `# >>> lanes mcp >>>` block with
+                              [mcp_servers.lanes]) and ~/.grok/user-settings.json (grok-cli: mcp.servers id `lanes`);
+                              `all` is that default set, a named harness is written even where its home is
+                              missing: prints the diff; --write applies
                               it, keeping <file>.bak-<UTC> first; an entry that is already there is left alone (a
                               Codex table missing those env_vars gains them), one named `lanes` that starts something
                               else is never replaced (exit 1). New agent sessions load it
@@ -527,7 +532,7 @@ def cmd_gc(args):
     print(f'lane gc --sockets: {removed} unlinked, {kept} kept in {directory}')
 
 
-MCP_USAGE = 'usage: lane mcp install [--agent claude|codex|all] [--write]'
+MCP_USAGE = 'usage: lane mcp install [--agent claude|codex|kimi|grok|grok-cli|all] [--write]'
 
 
 def cmd_mcp(args):
@@ -536,12 +541,12 @@ def cmd_mcp(args):
     left alone (not valid JSON/TOML, or a `lanes` entry that starts something else) or lane-mcp is not installed."""
     if not args or args[0] != 'install':
         sys.exit(MCP_USAGE)
-    agents, write, rest = C.MCP_AGENTS, False, list(args[1:])
+    agents, write, rest = None, False, list(args[1:])   # None: lane_core.mcp_agents (claude, codex, installed others)
     while rest:
         word = rest.pop(0)
-        if word == '--agent' and rest and rest[0] in ('claude', 'codex', 'all'):
+        if word == '--agent' and rest and rest[0] in C.MCP_AGENTS + ('all',):
             pick = rest.pop(0)
-            agents = C.MCP_AGENTS if pick == 'all' else (pick,)
+            agents = None if pick == 'all' else (pick,)   # all: claude, codex and every harness installed here
         elif word == '--write':
             write = True
         else:
@@ -576,7 +581,8 @@ def cmd_mcp(args):
                 print(f"backup {result['backup']}")
             print(f"wrote {result['path']}")
     if added:
-        print('new Claude Code and Codex sessions load it (a running session keeps its tools)')
+        print('new Claude Code and Codex sessions load it, and new Kimi Code, Grok Build and grok-cli ones where '
+              'their entry was written (a running session keeps its tools)')
     sys.exit(1 if refused else 0)
 
 

package/payload/lanes/container/lane-mcp

@@ -1,7 +1,9 @@
 #!/usr/bin/env python3
 """lane-mcp — the Lanes Agent API inside a workspace container: an MCP server on stdin/stdout (LNS-34/35, wire v1).
 Installed at /home/coder/.lz/bin/lane-mcp by `lanes install-container`; Claude Code and Codex start it from
-`mcpServers.lanes` in ~/.claude.json and `[mcp_servers.lanes]` in ~/.codex/config.toml (`lane mcp install`).
+`mcpServers.lanes` in ~/.claude.json and `[mcp_servers.lanes]` in ~/.codex/config.toml, Kimi Code from
+~/.kimi-code/mcp.json, Grok Build from `[mcp_servers.lanes]` in $GROK_HOME/config.toml and grok-cli from `mcp.servers`
+in ~/.grok/user-settings.json (`lane mcp install`, W12).
 
   usage: lane-mcp            (speaks MCP on stdin/stdout; nothing else to run by hand)
 
@@ -78,7 +80,27 @@ SYNC_PICKUP = 'lanes sync'
 STATUS_PICKUP = 'lanes-statusd'
 # A publish request: lanes-docsd's own pick-up cycle (5 s, plan W10 W4) takes it and writes the receipt back.
 PUBLISH_PICKUP, PUBLISH_LATENCY_S = C.PUBLISH_PICKUP, C.PUBLISH_LATENCY_S
-SESSION_VARS = ('CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID')   # the agent's session id, when its env carries one
+SESSION_VARS = ('CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID', 'GROK_SESSION_ID')   # the agent's session id, when known
+# The harness of the client that started this server (W12, DM-LANES-LANE-MCP), from its `clientInfo.name` (MEASURED:
+# Claude Code `claude-code`, Codex `codex-mcp-client`, Grok Build `grok-shell-<server>`, grok-cli `grok-cli-<id>`;
+# Kimi Code's names `kimi`), else the agent process above this one (lane_core.parent_harness), else `unknown`.
+HARNESS_FILTERS = ('claude', 'codex', 'kimi', 'grok', 'grok-cli')   # lanes_list `agent`
+
+
+def client_harness(client):
+    """The harness a client name says (spec W12 §2), else None."""
+    name = (client or '').lower()
+    if 'claude' in name:
+        return 'claude'
+    if 'codex' in name:
+        return 'codex'
+    if 'kimi' in name:   # kimi-code, kimi-code-acp, kimi
+        return 'kimi'
+    if name.startswith('grok-shell'):
+        return 'grok'
+    if name.startswith('grok-cli'):
+        return 'grok-cli'
+    return None
 # How long a lanes_signal report holds against the agent's own hooks (lane-signal's EXPLICIT rule, DEF-1801).
 SIGNAL_STANDS = ('your next tool call, a new prompt, a permission prompt, a failed turn or the session\'s end; the end '
                  'of your turn keeps it')
@@ -143,8 +165,9 @@ TOOLS = (
            'needs_you': {'type': 'boolean',
                          'description': 'true: only lanes whose agent waits for a person (needs_approval, errored, '
                                         'needs_input — the boards\' "Needs you" section).'},
-           'agent': {'type': 'string', 'enum': ['any', 'none', 'claude', 'codex'],
-                     'description': 'any: lanes with an agent; none: lanes without one; claude / codex: that harness.'}}),
+           'agent': {'type': 'string', 'enum': ['any', 'none', *HARNESS_FILTERS],
+                     'description': 'any: lanes with an agent; none: lanes without one; claude / codex / kimi / grok '
+                                    '(Grok Build) / grok-cli: that harness.'}}),
     _tool('lanes_status', 'Show one lane',
           'One lane in full: the registry facts (board, display name, kind, tmux socket and session, the declaring '
           'terminals.json and repository), the host\'s observation (state, agent, attached clients, viewers, last '
@@ -426,13 +449,16 @@ OBSERVED = ('attached', 'viewers', 'activity', 'size', 'stale', 'docs')
 
 
 class Server:
-    def __init__(self, root, environ=None, log=None, proc=Path('/proc'), home=None, signal=None):
+    def __init__(self, root, environ=None, log=None, proc=Path('/proc'), home=None, signal=None, parent=None):
         self.root, self.proc = Path(root), proc
         # The container's /home/coder as this process sees it: itself in a container (root ~/.lz), the volume a test
         # builds otherwise. Every container path a write tool reads or writes goes through local().
         self.home = Path(home) if home else self.root.parent
         self.signal = Path(signal) if signal else Path(__file__).resolve().parent / 'lane-signal'
         self.environ = os.environ if environ is None else environ
+        # The agent that started this server — read (whoami's environ fallback, the harness when the client's name
+        # says none) only when this server reads its own environment: a caller that hands one in names its own parent.
+        self.parent = parent if parent is not None else (os.getppid() if environ is None else None)
         self.log = log or Log(None)
         self.protocol = None
         self.client = ''
@@ -589,8 +615,21 @@ class Server:
         text = payload if isinstance(payload, str) else json.dumps(payload, ensure_ascii=False, indent=1)
         return {'content': [{'type': 'text', 'text': text}], 'isError': error}
 
+    def whoami(self):
+        """lane_core.whoami for the agent this server serves: its environment, then (grok-cli hands a server a
+        stripped one, DEF-1992) the agent's own /proc environ when this server reads its own environment."""
+        return C.whoami(self.root, self.environ, proc=self.proc, parent=self.parent)
+
+    def harness(self):
+        """The harness to record for this agent: the client's name (client_harness), else the agent's process
+        (lane_core.parent_harness, when this server reads its own environment), else `unknown`."""
+        found = client_harness(self.client)
+        if not found and self.parent is not None:
+            found = C.parent_harness(self.proc, self.parent)
+        return found or 'unknown'
+
     def tool_whoami(self, _arguments):
-        found = C.whoami(self.root, self.environ)
+        found = self.whoami()
         out = {'lane': found['lane'], 'found_by': found['found_by'], 'kind': found['kind']}
         entry, session = found.get('entry'), found.get('session')
         if entry:
@@ -643,7 +682,7 @@ class Server:
                 continue
             if want_agent == 'any' and not agent or want_agent == 'none' and agent:
                 continue
-            if want_agent in ('claude', 'codex') and (not agent or agent.get('harness') != want_agent):
+            if want_agent in HARNESS_FILTERS and (not agent or agent.get('harness') != want_agent):
                 continue
             picked.append(row)
         container = next((entry.get('container') for entry in lanes.values() if entry.get('container')), None)
@@ -876,7 +915,7 @@ class Server:
                     self.refuse_lane(wanted, lanes[wanted])
                 refuse('not_in_container', f'no unregistered session {wanted!r} in this container')
         else:
-            found = C.whoami(self.root, self.environ)
+            found = self.whoami()
             ghost = found.get('session') if found['kind'] == 'unregistered' else None
             if ghost is None:
                 if found.get('entry'):
@@ -981,7 +1020,7 @@ class Server:
         lanes, status = self.lanes()
         ws = arguments.get('workspace')
         if not ws:
-            found = C.whoami(self.root, self.environ)
+            found = self.whoami()
             ws = (found.get('entry') or {}).get('ws') or (found.get('session') or {}).get('workspace')
             if not ws:
                 boards = sorted({entry.get('ws') for entry in self.declared(lanes).values() if entry.get('ws')})
@@ -1068,25 +1107,25 @@ class Server:
         word, note = arguments['status'], arguments.get('note')
         if note is not None and self.unprintable(note):
             refuse('invalid_note', f'the note holds {", ".join(self.unprintable(note))}')
-        found = C.whoami(self.root, self.environ)
+        found = self.whoami()
         lane = found['lane']
         if not lane:
             refuse('not_in_lane', found.get('why') or 'this agent runs in no lane',
                    'lanes_signal reports the lane this agent runs in: start the agent inside a lane (for Codex, '
                    '`lane mcp install` passes the lane\'s variables to this server).')
-        client = self.client.lower()
-        harness = ('claude' if 'claude' in client else 'codex' if 'codex' in client
-                   else 'claude' if self.environ.get('CLAUDE_CODE_ENTRYPOINT') else '')
+        # Always a harness (DEF-1991): before W12 a client whose name said neither claude nor codex, outside Claude
+        # Code's environment, passed none, and lane-signal's old default recorded it as Codex.
+        harness = self.harness()
         # The agent is this server's parent (Claude Code and Codex start it directly): lane-signal records ITS pid,
         # so the host's liveness check follows the agent, not this process.
-        argv = [sys.executable, str(self.signal), word, '--event', 'lanes_signal', '--agent-pid', str(os.getppid())]
-        argv += ['--harness', harness] if harness else []
+        argv = [sys.executable, str(self.signal), word, '--event', 'lanes_signal', '--agent-pid', str(os.getppid()),
+                '--harness', harness]
         argv += ['--note', note] if note is not None else []
         env = {'PATH': os.environ.get('PATH') or '/usr/bin:/bin', 'HOME': str(self.home), 'LANG': 'C.UTF-8',
                'LANE_ROOT': str(self.root), 'LANE_ID': lane}
         # The agent's session, so the sidecar names the session its own hooks name (their stdin's `session_id`):
         # Claude Code gives its MCP servers CLAUDE_CODE_SESSION_ID (MEASURED 2026-10-06 in a server's environ; it
-        # equals the session's transcript id). lane-signal matches a report to the agent's hooks by the agent's pid and
+        # equals the session's transcript id); Grok Build GROK_SESSION_ID (its source, evidence 2026-10-15 §5). lane-signal matches a report to the agent's hooks by the agent's pid and
         # starttime first (Codex clears a server's environment; a /clear gives the agent a new session), then by this
         # session (DEF-1801).
         env.update({key: self.environ[key] for key in SESSION_VARS if self.environ.get(key)})
@@ -1108,7 +1147,7 @@ class Server:
 
 
     def tool_publish(self, arguments):
-        found = C.whoami(self.root, self.environ)
+        found = self.whoami()
         lane = found['lane']
         if not lane:
             refuse('not_in_lane', found.get('why') or 'this agent runs in no lane',

package/payload/lanes/container/lane-signal

@@ -1,17 +1,19 @@
 #!/usr/bin/env python3
-"""lane-signal <status> [--event NAME] [--harness claude|codex] [--note TEXT] [--agent-pid PID] [PAYLOAD] — the hook
-target of Claude Code and Codex inside a workspace container, and the writer behind lane-mcp's `lanes_signal`. Writes
-~/.lz/state/hooks/<lane id>.json (atomic replace), which the host's lanes-statusd reads through /proc/<container init
-pid>/root and publishes as the lane's `agent{}` (source `hook`).
+"""lane-signal <status> [--event NAME] [--harness claude|codex|kimi|grok|grok-cli|unknown] [--note TEXT]
+[--agent-pid PID] [PAYLOAD] — the hook target of Claude Code, Codex, Kimi Code, Grok Build and grok-cli inside a
+workspace container, and the writer behind lane-mcp's `lanes_signal`. Writes ~/.lz/state/hooks/<lane id>.json
+(atomic replace), which the host's lanes-statusd reads through /proc/<container init pid>/root and publishes as the
+lane's `agent{}` (source `hook`).
 
 The sidecar has its own directory because `lane-run`, the root process of every zmx-held lane, writes its
 `{phase, exit, at, pid}` record to ~/.lz/state/<zmx name>.json and exports LANE_ID=<zmx name> to the agent: a
 sidecar at state/<lane id>.json would overwrite that record for the agent's whole life (DEF-1572). Nothing but
 this script writes state/hooks/, and lane-run never writes there.
 
-    {"v":1, "lane":"<id>", "harness":"claude|codex", "status":"<agent{} vocabulary>", "since":<epoch the status
-     began>, "at":<epoch of this event>, "event":"<hook event>", "pid":<agent pid>, "start":"<its starttime>",
-     "session":"<session/thread id or ''>", "name":"<the agent's own note>" (only when there is one)}
+    {"v":1, "lane":"<id>", "harness":"claude|codex|kimi|grok|grok-cli|unknown", "status":"<agent{} vocabulary>",
+     "since":<epoch the status began>, "at":<epoch of this event>, "event":"<hook event>", "pid":<agent pid>,
+     "start":"<its starttime>", "session":"<session/thread id or ''>", "name":"<the agent's own note>" (only when
+     there is one)}
 
 It never fails the agent and never speaks: every path exits 0 and nothing reaches stdout or stderr (a Claude Code
 UserPromptSubmit/SessionStart hook's stdout becomes model context). An unresolvable lane, a status outside the
@@ -28,10 +30,17 @@ Agent pid: --agent-pid when that process exists (lane-mcp passes its own parent,
 default rule below would name lane-mcp itself); else the parent process, or that parent's parent when the parent is
 a shell (Claude Code runs a hook command through a shell, which may fork it rather than exec it; a pid that dies
 with the shell would read as a dead agent).
-Session id: `session_id` of the hook's JSON on stdin, `thread-id` of a JSON PAYLOAD argument (Codex `notify` passes
-its JSON as the last argument), else $CLAUDE_CODE_SESSION_ID / $CODEX_THREAD_ID (lane-mcp passes the first: Claude
-Code gives it to its MCP servers). Stdin is read only when it is not a terminal and for at most STDIN_WAIT seconds:
-a stdin that never closes cannot hang the hook.
+Session id: `session_id` of the hook's JSON on stdin (Grok Build's camel-case `sessionId` too), `thread-id` of a JSON
+PAYLOAD argument (Codex `notify` passes its JSON as the last argument), else $CLAUDE_CODE_SESSION_ID / $CODEX_THREAD_ID
+/ $GROK_SESSION_ID (lane-mcp passes the first and the last: Claude Code and Grok Build give them to their MCP servers;
+Grok Build also sets GROK_SESSION_ID for every hook it runs).
+Harness (W12, DEF-1990): --harness when it is one of HARNESSES, else $LANE_HARNESS (the same rule), else the first
+process up the parent chain (PARENT_DEPTH steps from this process's parent) whose comm is a harness's
+(HARNESS_COMMS: claude, codex, kimi, kimi-code, grok; a `grok` is Grok Build when /proc/<pid>/exe ends in
+GROK_BUILD_EXE, else grok-cli; any comm whose exe holds CLAUDE_EXE is Claude Code), else `unknown` — never `codex`:
+before W12 every hook without --harness and outside Claude Code was recorded as Codex. $LANE_PROC names another /proc for the chain and the agent's starttime (tests).
+Stdin is read only when it is not a terminal and for at most STDIN_WAIT seconds: a stdin that never closes cannot hang
+the hook.
 The same agent: the same process (pid and starttime: lane-mcp's parent and a hook's are the agent), else the same
 session when both writes name one (lane-mcp under Codex knows no session; the agent's hooks do).
 
@@ -67,7 +76,12 @@ NOTE_MAX = 120
 EXPLICIT = 'lanes_signal'   # the --event of lane-mcp's lanes_signal: the agent's own word
 REPORT_TOOL = 'lanes_signal'   # its tool name; Claude Code names an MCP tool mcp__<server>__<tool>
 RESTING = {('Stop', 'needs_input'), ('Stop', 'done'), ('Notification', 'needs_input')}   # the hooks' "turn ended"
-SESSION_VARS = ('CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID')
+SESSION_VARS = ('CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID', 'GROK_SESSION_ID')
+HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'unknown')   # agent{}.harness, but `shell`
+HARNESS_COMMS = {'claude': 'claude', 'codex': 'codex', 'kimi': 'kimi', 'kimi-code': 'kimi', 'grok': 'grok'}
+GROK_BUILD_EXE = '/downloads/grok-linux-x86_64'   # Grok Build's file ($GROK_HOME/downloads/…); grok-cli's: bin/grok
+CLAUDE_EXE = '/claude/versions/'   # native Claude Code before 2.1.299 kept its file's name, the version, as comm (MEASURED)
+PARENT_DEPTH = 8
 
 
 def options(argv):
@@ -115,15 +129,15 @@ def lane_id(root):
     return found if LANE_ID.fullmatch(found or '') else ''
 
 
-def stat_fields(pid):
+def stat_fields(pid, proc='/proc'):
     """Fields after `comm` of /proc/<pid>/stat (state is [0], ppid [1], starttime [19]) and the comm itself."""
-    with open(f'/proc/{pid}/stat') as handle:
+    with open(f'{proc}/{pid}/stat') as handle:
         text = handle.read()
     comm = text[text.index('(') + 1:text.rindex(')')]
     return comm, text.rsplit(')', 1)[1].split()
 
 
-def agent(given=None):
+def agent(given=None, proc='/proc'):
     """(pid, starttime) of the agent: `given` (--agent-pid) when that process exists, else the parent — or the
     parent's parent when the parent is a shell."""
     try:
@@ -132,20 +146,69 @@ def agent(given=None):
         pid = 0
     if pid > 1:
         try:
-            return pid, stat_fields(pid)[1][19]
+            return pid, stat_fields(pid, proc)[1][19]
         except (OSError, ValueError, IndexError):
             pass   # gone (or never there): the parent rule below names the agent
     pid = os.getppid()
     try:
-        comm, fields = stat_fields(pid)
+        comm, fields = stat_fields(pid, proc)
         if comm in SHELLS and int(fields[1]) > 1:
             pid = int(fields[1])
-            comm, fields = stat_fields(pid)
+            comm, fields = stat_fields(pid, proc)
         return pid, fields[19]
     except (OSError, ValueError, IndexError):
         return pid, None
 
 
+def exe_of(pid, proc='/proc'):
+    """The path /proc/<pid>/exe names ('' when it cannot be read), without the kernel's ` (deleted)`."""
+    try:
+        return os.readlink(f'{proc}/{pid}/exe').removesuffix(' (deleted)')
+    except OSError:
+        return ''
+
+
+def process_harness(comm, pid, proc='/proc'):
+    """The harness process `pid` (whose comm is `comm`) is, or None. A `grok` is Grok Build when its executable is
+    $GROK_HOME/downloads/grok-linux-x86_64 (the installer's file, run through the bin/grok link), anything else grok-cli
+    (its own bin/grok, a real file); a process running a native Claude Code file (…/claude/versions/<version>) is
+    Claude Code whatever its comm."""
+    found = HARNESS_COMMS.get(comm)
+    if found == 'grok':
+        return 'grok' if exe_of(pid, proc).endswith(GROK_BUILD_EXE) else 'grok-cli'
+    if found:
+        return found
+    return 'claude' if CLAUDE_EXE in exe_of(pid, proc) else None
+
+
+def parent_harness(proc='/proc', start=None):
+    """The harness of the first process up the parent chain whose comm is a harness's (HARNESS_COMMS), at most
+    PARENT_DEPTH steps from `start` (default: this process's parent), else ''. A hook runs as the harness's child or a
+    shell's; lane-mcp's lanes_signal as lane-mcp's child, whose parent is the agent."""
+    pid = os.getppid() if start is None else start
+    for _step in range(PARENT_DEPTH):
+        if pid <= 1:
+            break
+        try:
+            comm, fields = stat_fields(pid, proc)
+            parent = int(fields[1])
+        except (OSError, ValueError, IndexError):
+            break
+        found = process_harness(comm, pid, proc)
+        if found:
+            return found
+        pid = parent
+    return ''
+
+
+def harness_of(given, proc='/proc'):
+    """--harness, else $LANE_HARNESS, each only when it is one of HARNESSES; else the parent chain; else `unknown`."""
+    for word in (given, os.environ.get('LANE_HARNESS') or ''):
+        if word in HARNESSES:
+            return word
+    return parent_harness(proc) or 'unknown'
+
+
 def stdin_doc():
     """The hook's JSON on stdin as a dict ({} when there is none): Claude Code and Codex pass `session_id`,
     `hook_event_name` and, for a tool event, `tool_name`."""
@@ -194,7 +257,7 @@ def main(argv):
     if not lane:
         return
     hook = stdin_doc()
-    session = str(hook.get('session_id') or '')
+    session = str(hook.get('session_id') or hook.get('sessionId') or '')
     if not session and payload:
         try:
             doc = json.loads(payload)
@@ -202,10 +265,10 @@ def main(argv):
         except ValueError:
             session = ''
     session = (session or next((os.environ[key] for key in SESSION_VARS if os.environ.get(key)), ''))[:128]
-    given_harness = harness
-    harness = harness or os.environ.get('LANE_HARNESS') or ('claude' if os.environ.get('CLAUDE_CODE_ENTRYPOINT')
-                                                            else 'codex')
-    pid, start = agent(agent_pid)
+    proc = os.environ.get('LANE_PROC') or '/proc'
+    given_harness = harness if harness in HARNESSES else ''
+    harness = harness_of(harness, proc)
+    pid, start = agent(agent_pid, proc)
     now = int(time.time())
     state = os.path.join(root, 'state', 'hooks')   # never state/<id>.json: lane-run's phase record (DEF-1572)
     path = os.path.join(state, f'{lane}.json')