@vibelord/lanes 1.2.0 → 1.5.0

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

@@ -23,10 +23,21 @@ a `holder: tmux` lane through its exact socket and session; any other id is a zm
                               hook sidecar says the agent is `working` unless --force
   lane gc --sockets           unlink this container's tmux socket files that tmux is refused on (ECONNREFUSED: no
                               server listens); prints each unlinked path. A live, empty or silent server keeps its file
-  lane mcp install [--agent claude|codex|all] [--write]
+  lane publish <file> [--title T] [--for <login>] [--kind md|html|svg|file]
+                              put the file on the Lanes docs page from the lane this runs in ($LANE_ID, else the tmux
+                              pane): writes ~/.lz/state/publish/<lane>/<id>.json (the file's container path, hashed
+                              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|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
@@ -521,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):
@@ -530,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:
@@ -570,12 +581,48 @@ 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)
 
 
+PUBLISH_USAGE = 'usage: lane publish <file> [--title T] [--for <login>] [--kind md|html|svg|file]'
+
+
+def cmd_publish(args):
+    """`lane publish` (plan W10 W4): lane_core.publish from the lane this process runs in (lane_core.whoami: $LANE_ID,
+    else the tmux pane) for the file named relative to the working directory. Prints the answer as JSON on stdout
+    (what lanes_publish answers) and one line for a person on stderr. A refusal is one stderr line, exit 1."""
+    options, rest, path = {}, list(args), None
+    while rest:
+        word = rest.pop(0)
+        if word in ('--title', '--for', '--kind'):
+            if not rest or word in options:
+                sys.exit(PUBLISH_USAGE)
+            options[word] = rest.pop(0)
+        elif word.startswith('--') or path is not None:
+            sys.exit(PUBLISH_USAGE)
+        else:
+            path = word
+    if path is None:
+        sys.exit(PUBLISH_USAGE)
+    found = C.whoami(ROOT, os.environ)
+    if not found['lane']:
+        sys.exit(f"lane publish: {found.get('why') or 'not inside a lane'}")
+    try:
+        out = C.publish(ROOT, Path(os.environ.get('HOME') or Path.home()), os.path.abspath(path), found['lane'],
+                        title=options.get('--title'), for_login=options.get('--for'), kind=options.get('--kind'))
+    except C.LaneError as error:
+        sys.exit(f'lane publish: {error}')
+    out.update(picked_up_by=C.PUBLISH_PICKUP, expected_within_s=C.PUBLISH_LATENCY_S)
+    print(json.dumps(out, ensure_ascii=False, indent=1))
+    sys.stderr.write(f"lane publish: {out['path']} ({out['kind']}, {out['bytes']} bytes) -> request {out['id']} of "
+                     f"{out['lane']}; {C.PUBLISH_PICKUP} takes it within ~{C.PUBLISH_LATENCY_S} s and answers in "
+                     f"{out['receipt']}\n")
+
+
 COMMANDS = {'new': cmd_new, 'open': cmd_open, 'attach': cmd_attach, 'send': cmd_send, 'capture': cmd_capture, 'ls': cmd_ls,
-            'status': cmd_status, 'kill': cmd_kill, 'gc': cmd_gc, 'mcp': cmd_mcp}
+            'status': cmd_status, 'kill': cmd_kill, 'gc': cmd_gc, 'mcp': cmd_mcp, 'publish': cmd_publish}
 
 if __name__ == '__main__':
     if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:

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)
 
@@ -18,7 +20,8 @@ capture's text, a sent text or a note), rotated to .1 past 1 MiB.
 Read tools (the lanes of THIS container: what ~/.lz/registry.json and ~/.lz/status.json hold):
   lanes_whoami                 which lane this agent runs in ($LANE_ID, else its tmux pane's session)
   lanes_list [workspace] [needs_you] [agent]   every lane here with its state and agent
-  lanes_status <lane>          one lane in full: registry facts, observed state, agent, tmux liveness, hook sidecar
+  lanes_status <lane>          one lane in full: registry facts, observed state, agent, documents (`docs`), tmux
+                               liveness, hook sidecar, and the lane's latest publish receipt (`published`)
   lanes_capture <lane> [lines] the last N (1–500, default 100) non-blank lines of that lane's screen and scrollback
 
 Write tools (LNS-35). Each answers JSON: on success what changed, what picks it up (`picked_up_by`) and when
@@ -34,8 +37,12 @@ terminal); `lanes sync` publishes the change (lanes-statusd starts one within ~1
   lanes_signal <status> [note]  report this agent's own status (and a one-line note) through lane-signal; the report
                                stands until the agent's next tool call, prompt or permission prompt, and the end of
                                its turn keeps it (lane-signal's EXPLICIT rule)
+  lanes_publish <path> [title] [for] [kind]   put a file of this container on the Lanes docs page from this agent's
+                               own lane (plan W10 W4): a request in ~/.lz/state/publish/<lane>/ that the host's
+                               lanes-docsd takes within ~5 s, answering in <id>.receipt.json (lane_core.publish)
 Human-only by omission (no tool exists): ending or closing a lane, interrupting it (C-c or any key that is not
-printable text), opening or attaching one, uploads, the host's sync/gc/ensure, renaming a tmux session, and any
+printable text), opening or attaching one, uploads (a person's file into a lane: the Docs page or the desktop drop;
+an agent's own file goes the other way, lanes_publish), the host's sync/gc/ensure, renaming a tmux session, and any
 edit of an adopted (`lanes register`ed, `--x-`) session — those stay with a person on the boards or the host.
 """
 import json
@@ -71,7 +78,29 @@ PATH_MAX, COMMAND_MAX = 1024, 1024
 SYNC_LATENCY_S, STATUS_LATENCY_S = 15, 5
 SYNC_PICKUP = 'lanes sync'
 STATUS_PICKUP = 'lanes-statusd'
-SESSION_VARS = ('CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID')   # the agent's session id, when its env carries one
+# 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', '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')
@@ -86,7 +115,9 @@ INSTRUCTIONS = ('Lanes tools for the workspace container this agent runs in. A l
                 'display name, lanes_new declares and starts a new lane, lanes_send types text into a lane (refused '
                 'while its agent is working or waiting for an approval unless force: true), lanes_signal reports '
                 'your own status with a short note. Every write answers what changed, what picks it up and when; a '
-                'refusal answers a machine code and what a person can do instead. Ending, interrupting or attaching '
+                'refusal answers a machine code and what a person can do instead. lanes_publish puts a file of this '
+                'container on the Lanes docs page, where the people on your boards open it (the host takes it within '
+                'about 5 s; lanes_status shows the receipt as `published`). Ending, interrupting or attaching '
                 'a lane is a person\'s call: no tool does it.')
 
 ID_PATTERN = '^[A-Za-z0-9_][A-Za-z0-9_.-]*$'
@@ -134,13 +165,15 @@ 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 '
-          'activity, size, stale), whether its tmux session is alive now (null when tmux did not answer) and its '
-          'lane-signal hook sidecar.',
+          'activity, size, stale, and `docs`: how many documents the docs page holds for the lane and when the '
+          'newest arrived), whether its tmux session is alive now (null when tmux did not answer), its '
+          'lane-signal hook sidecar, and `published`: the lane\'s latest publish receipt (id, url, at, outcome).',
           {'lane': LANE_ARG}, required=('lane',)),
     _tool('lanes_capture', 'Read a lane\'s screen',
           'The last `lines` non-blank lines of a tmux lane\'s screen and scrollback, as plain text (wrapped lines '
@@ -213,6 +246,25 @@ TOOLS = (
                     'description': f'What you are doing, one line of at most {NOTE_MAX} characters; "" clears it. '
                                    'Kept while the report stands or its status repeats.'}},
           required=('status',), hints=_writes(False, True)),
+    _tool('lanes_publish', 'Publish a file to the docs page',
+          'Put a file of this container on the Lanes docs page, from the lane this agent runs in: Markdown (with '
+          'Mermaid diagrams) is rendered there, an HTML or SVG artifact opens sandboxed on its own page, any other '
+          'file is offered as a download. Writes a request the host\'s lanes-docsd takes within about 5 s; it reads '
+          'the file itself, checks its sha256 against the one answered here and writes a receipt that lanes_status '
+          'shows as `published` (outcome ok with the document\'s url, or refused with the reason). The file must be '
+          f'under /home/coder (every link resolved) and at most {C.PUBLISH_MAX >> 20} MiB. Who sees it: `for`, else '
+          'the person who last opened this lane, else every member whose record lists the lane\'s board.',
+          {'path': {'type': 'string', 'minLength': 1, 'maxLength': PATH_MAX,
+                    'description': 'The file: an absolute path under /home/coder.'},
+           'title': {'type': 'string', 'maxLength': C.TITLE_MAX,
+                     'description': f'The title the docs page shows, one line of at most {C.TITLE_MAX} characters; '
+                                    'default: the file name.'},
+           'for': {'type': 'string', 'minLength': 1, 'maxLength': C.LOGIN_MAX,
+                   'description': 'The tailnet login of the member the document is for (only they see it).'},
+           'kind': {'type': 'string', 'enum': list(C.PUBLISH_KINDS),
+                    'description': 'md, html, svg or file; default: from the extension (.md/.markdown, .html/.htm, '
+                                   '.svg, anything else file).'}},
+          required=('path',), hints=_writes(False, False)),
 )
 TOOL_BY_NAME = {tool['name']: tool for tool in TOOLS}
 WRITE_TOOLS = frozenset(tool['name'] for tool in TOOLS if not tool['annotations']['readOnlyHint'])
@@ -280,6 +332,13 @@ HUMAN = {
     'tmux_failed': 'lanes_status says whether the lane is running.',
     'signal_not_written': 'A person checks the lane-signal install (`lanes install-container <container>` on the '
                           'host).',
+    'outside_home': 'Publish a file under /home/coder: copy it there first (a link that leads outside is refused).',
+    'not_a_file': 'Pass an existing regular file (not a directory, FIFO or device).',
+    'too_large': f'A published file is at most {C.PUBLISH_MAX >> 20} MiB: publish a smaller one, or tell a person '
+                 'where the file is.',
+    'invalid_title': 'A title is one line of printable text without leading or trailing spaces.',
+    'invalid_for': 'Pass one tailnet login (as `anna@example.com`), or leave `for` out.',
+    'invalid_kind': 'Pass md, html, svg or file, or leave `kind` out.',
     'refused': 'A person takes it from here.',
 }
 
@@ -384,17 +443,22 @@ def agent_summary(agent):
     return {key: agent[key] for key in ('harness', 'status', 'name', 'since') if agent.get(key) is not None}
 
 
-OBSERVED = ('attached', 'viewers', 'activity', 'size', 'stale')
+# The observed keys a row copies from ~/.lz/status.json when present. `docs` ({n, at}: the documents the docs cockpit
+# holds for the lane, plan W10 W7) is an additive result key within wire v1, absent while the lane has none.
+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 = ''
@@ -551,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:
@@ -605,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)
@@ -643,6 +720,9 @@ class Server:
             alive = None if code in (124, 127) else code == 0
         out['alive'] = alive
         out['hook'] = C.hook_agent(self.root / 'state' / 'hooks', lane, self.proc) or None
+        published = C.latest_receipt(self.root, lane)   # plan W10 W4: read here, in the container, never via status.json
+        if published:
+            out['published'] = published
         out['status'] = freshness(status)
         return out
 
@@ -835,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'):
@@ -940,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')})
@@ -1027,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)})
@@ -1066,6 +1146,24 @@ class Server:
                 'picked_up_by': STATUS_PICKUP, 'expected_within_s': STATUS_LATENCY_S}
 
 
+    def tool_publish(self, arguments):
+        found = self.whoami()
+        lane = found['lane']
+        if not lane:
+            refuse('not_in_lane', found.get('why') or 'this agent runs in no lane',
+                   'lanes_publish publishes from 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).')
+        try:
+            local = self.local(arguments['path'])
+        except ValueError as error:
+            refuse('outside_home', f'{error}: pass an absolute path under {C.CONTAINER_HOME}')
+        out = C.publish(self.root, self.home, local, lane, title=arguments.get('title'),
+                        for_login=arguments.get('for'), kind=arguments.get('kind'))
+        return {**out, 'changed': f'{out["request"]}: a publish request for {out["path"]} ({out["kind"]}, '
+                                  f'{out["bytes"]} bytes, sha256 {out["sha256"]})',
+                'picked_up_by': PUBLISH_PICKUP, 'expected_within_s': PUBLISH_LATENCY_S}
+
+
 def main(argv):
     if argv:
         if argv[0] in ('-h', '--help'):