@vibelord/lanes 1.2.0 → 1.5.0

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')