@vibelord/lanes 1.5.0 → 1.6.0

package/payload/lanes/container/lane-signal

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
-"""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
+"""lane-signal <status> [--event NAME] [--harness claude|codex|kimi|grok|grok-cli|muse|zcode|unknown] [--note TEXT]
+[--agent-pid PID] [PAYLOAD] — the hook target of Claude Code, Codex, Kimi Code, Grok Build, grok-cli, Muse Code and
+ZCode 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`).
 
@@ -10,7 +10,7 @@ The sidecar has its own directory because `lane-run`, the root process of every
 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|kimi|grok|grok-cli|unknown", "status":"<agent{} vocabulary>",
+    {"v":1, "lane":"<id>", "harness":"claude|codex|kimi|grok|grok-cli|muse|zcode|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)}
@@ -24,7 +24,11 @@ Lane id: $LANE_ID — exported in a tmux lane only by a canonical/`--identity` r
 `<ws>--z-<name>` id lanes-statusd publishes for it, so statusd does not join that sidecar to the zmx lane yet:
 DEF-1573) — else the pane's tmux session (`tmux -S ${TMUX%%,*} display -p -t $TMUX_PANE '#S'`) looked up by (socket
 name, session) in ~/.lz/registry.json, the projection `lanes sync` writes. lane-mcp passes the lane it resolved as
-$LANE_ID.
+$LANE_ID. W13 (DEF-2031): when this process has neither LANE_ID nor TMUX — Muse Code runs a hook with an environment
+cleared to an allow-list (HOME, PATH, TERM, LANG, LC_ALL, USER, LOGNAME, SHELL, TMPDIR, MUSE_SESSION_ID,
+MUSE_THREAD_ID; MEASURED 2026-10-16, muse 1.4.10) — the agent's own /proc/<pid>/environ stands in for LANE_ID, LANE_WS,
+TMUX and TMUX_PANE, read only when that pid is a known harness, bounded (ENVIRON_MAX) and without following a link
+(`agent_environ`, lane_core.parent_environ's rule, pinned equal by test_lane_signal).
 
 Agent pid: --agent-pid when that process exists (lane-mcp passes its own parent, the agent that started it: the
 default rule below would name lane-mcp itself); else the parent process, or that parent's parent when the parent is
@@ -32,12 +36,15 @@ a shell (Claude Code runs a hook command through a shell, which may fork it rath
 with the shell would read as a dead agent).
 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).
+/ $GROK_SESSION_ID / $MUSE_SESSION_ID / $ZCODE_SESSION_ID (lane-mcp passes them: Claude Code, Grok Build and Muse Code
+give them to their MCP servers; Grok Build, Muse Code and ZCode also set theirs for every hook they run).
+A PostToolUseFailure whose hook JSON says `is_interrupt: true` is the person interrupting the turn: needs_input,
+whatever status the hook names (ZCode sends no Stop after an interrupt, DEF-2091).
 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`:
+(HARNESS_COMMS: claude, codex, kimi, kimi-code, grok, muse, zcode-cli; a `grok` is Grok Build when /proc/<pid>/exe ends
+in GROK_BUILD_EXE, else grok-cli; a comm starting `muse-bin-` or an exe whose file name does is Muse Code; 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.
@@ -62,6 +69,7 @@ import json
 import os
 import re
 import select
+import stat
 import subprocess
 import sys
 import time
@@ -76,12 +84,16 @@ 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', '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'}
+SESSION_VARS = ('CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID', 'GROK_SESSION_ID', 'MUSE_SESSION_ID', 'ZCODE_SESSION_ID')
+HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'muse', 'zcode', 'unknown')   # agent{}.harness, but `shell`
+HARNESS_COMMS = {'claude': 'claude', 'codex': 'codex', 'kimi': 'kimi', 'kimi-code': 'kimi', 'grok': 'grok',
+                 'muse': 'muse', 'zcode-cli': 'zcode'}
+MUSE_PREFIX = 'muse-bin-'   # Muse Code's binary `muse-bin-<version>` and its comm (MEASURED 2026-10-16: muse-bin-1.4.10)
 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
+ENVIRON_MAX = 1 << 20   # lane_core.ENVIRON_MAX: /proc/<pid>/environ read at most this far
+IDENTITY_VARS = ('LANE_ID', 'LANE_WS', 'TMUX', 'TMUX_PANE')   # lane_core.WHOAMI_VARS
 
 
 def options(argv):
@@ -109,12 +121,13 @@ def clean_note(text):
     return ' '.join(kept.split())[:NOTE_MAX]
 
 
-def lane_id(root):
-    found = os.environ.get('LANE_ID', '')
-    if not found and os.environ.get('TMUX') and os.environ.get('TMUX_PANE'):
-        sock = os.environ['TMUX'].split(',', 1)[0]
+def lane_id(root, environ=None):
+    environ = os.environ if environ is None else environ
+    found = environ.get('LANE_ID', '')
+    if not found and environ.get('TMUX') and environ.get('TMUX_PANE'):
+        sock = environ['TMUX'].split(',', 1)[0]
         try:
-            done = subprocess.run(['tmux', '-S', sock, 'display', '-p', '-t', os.environ['TMUX_PANE'], '#S'],
+            done = subprocess.run(['tmux', '-S', sock, 'display', '-p', '-t', environ['TMUX_PANE'], '#S'],
                                   stdin=subprocess.DEVNULL, capture_output=True, text=True, timeout=1)
             session = done.stdout.strip() if done.returncode == 0 else ''
             lanes = json.load(open(os.path.join(root, 'registry.json'))).get('lanes') or {}
@@ -178,7 +191,54 @@ def process_harness(comm, pid, proc='/proc'):
         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
+    if comm.startswith(MUSE_PREFIX):
+        return 'muse'
+    exe = exe_of(pid, proc)
+    if CLAUDE_EXE in exe:
+        return 'claude'
+    return 'muse' if exe.rpartition('/')[2].startswith(MUSE_PREFIX) else None
+
+
+def agent_environ(pid, proc='/proc', names=IDENTITY_VARS):
+    """{name: value} of `names` in /proc/<pid>/environ when `pid` is a known harness (process_harness) — {} otherwise
+    (lane_core.parent_environ's rule). Bounded (ENVIRON_MAX), never through a link (O_NOFOLLOW on the file; /proc's own
+    entries are not links), never blocking; entries are NUL-split and one that is not UTF-8 or holds no `=` is skipped."""
+    try:
+        pid = int(pid)
+        if pid <= 1:
+            return {}
+        comm = stat_fields(pid, proc)[0]
+    except (OSError, ValueError, IndexError, TypeError):
+        return {}
+    if not process_harness(comm, pid, proc):
+        return {}
+    try:
+        fd = os.open(f'{proc}/{pid}/environ', os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK | getattr(os, 'O_CLOEXEC', 0))
+    except OSError:
+        return {}
+    try:
+        if not stat.S_ISREG(os.fstat(fd).st_mode):
+            return {}
+        data, chunk = b'', b'x'
+        while chunk and len(data) <= ENVIRON_MAX:
+            chunk = os.read(fd, ENVIRON_MAX + 1 - len(data))
+            data += chunk
+    except OSError:
+        return {}
+    finally:
+        os.close(fd)
+    if len(data) > ENVIRON_MAX:
+        return {}
+    found = {}
+    for item in data.split(b'\0'):
+        key, sep, value = item.partition(b'=')
+        try:
+            key, value = key.decode('utf-8'), value.decode('utf-8')
+        except UnicodeDecodeError:
+            continue
+        if sep and key in names and value and key not in found:
+            found[key] = value
+    return found
 
 
 def parent_harness(proc='/proc', start=None):
@@ -253,10 +313,19 @@ def main(argv):
     if status not in STATUSES:
         return
     root = os.environ.get('LANE_ROOT') or os.path.join(os.path.expanduser('~'), '.lz')
-    lane = lane_id(root)
+    proc = os.environ.get('LANE_PROC') or '/proc'
+    pid, start = agent(agent_pid, proc)
+    environ = None
+    if not os.environ.get('LANE_ID') and not os.environ.get('TMUX'):
+        inherited = agent_environ(pid, proc)   # a harness that cleared its hooks' environment (Muse Code, DEF-2031)
+        if inherited.get('LANE_ID') or (inherited.get('TMUX') and inherited.get('TMUX_PANE')):
+            environ = dict(os.environ, **inherited)
+    lane = lane_id(root, environ)
     if not lane:
         return
     hook = stdin_doc()
+    if event == 'PostToolUseFailure' and hook.get('is_interrupt') is True:
+        status = 'needs_input'   # the person interrupted the turn; ZCode sends no Stop after it (DEF-2091)
     session = str(hook.get('session_id') or hook.get('sessionId') or '')
     if not session and payload:
         try:
@@ -265,10 +334,8 @@ def main(argv):
         except ValueError:
             session = ''
     session = (session or next((os.environ[key] for key in SESSION_VARS if os.environ.get(key)), ''))[:128]
-    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')

package/payload/lanes/container/lane_core.py

@@ -59,7 +59,10 @@ STATUS_FRESH = 60         # status.json `at` is renewed at least every 15 s (sta
 READ_MAX = 16 << 20       # a projection bigger than this is not ours
 TMUX_TIMEOUT = 5
 IDENTITY = ('LANE_ID', 'LANE_WS', 'THROTTLE_TRACE', 'LANES_TRACE')   # + our trace headers and GROK_HOME (identity_free)
-TRACE_HEADERS = ('ANTHROPIC_CUSTOM_HEADERS', 'KIMI_CODE_CUSTOM_HEADERS')   # ours: 'x-throttle-trace: lanes/<ws>/<id>'
+# Ours: 'x-throttle-trace: lanes/<ws>/<id>'. W13: MUSE_CUSTOM_HEADERS reaches Muse Code's model requests (MEASURED
+# 2026-10-16 on muse 1.4.10: the header arrived on its `GET …/models`; undocumented by Meta, so it may stop working in a
+# later release — DEF-2059). ZCode has no per-process header (its api.headers are static config): no trace.
+TRACE_HEADERS = ('ANTHROPIC_CUSTOM_HEADERS', 'KIMI_CODE_CUSTOM_HEADERS', 'MUSE_CUSTOM_HEADERS')
 GROK_HOME = CONTAINER_HOME + '/.grok-build'   # Grok Build's home in a lane, never grok-cli's ~/.grok (DM-LANES-GROK-HOME)
 
 
@@ -213,7 +216,8 @@ def identity_free(environ, drop=('TMUX',)):
     a socket's server hands its whole environment to the server's GLOBAL environment, and every later session on
     that socket created without its own `-e` inherits it (MEASURED, tmux 3.4: DEF-1559). Board sockets are shared by
     many lanes, so a lane identity in the env of anything that may start one would be stamped on unrelated lanes.
-    An operator's own ANTHROPIC_CUSTOM_HEADERS / KIMI_CODE_CUSTOM_HEADERS that is not a lane trace is theirs and stays,
+    An operator's own ANTHROPIC_CUSTOM_HEADERS / KIMI_CODE_CUSTOM_HEADERS / MUSE_CUSTOM_HEADERS that is not a lane trace
+    is theirs and stays,
     and so is a GROK_HOME that is not the one the recipe stamps (W12)."""
     return {k: v for k, v in environ.items() if k not in drop and k not in IDENTITY
             and not (k in TRACE_HEADERS and v.startswith('x-throttle-trace: lanes/'))
@@ -309,7 +313,7 @@ def last_lines(text, lines):
 def new_session_argv(socket, session, cwd, lane_id, ws, command):
     """The one tmux client lane-mcp runs WITHOUT -N (`lanes_new`): it creates the session, and starts the socket's
     server when none runs. The lane's identity reaches the session only through these `-e` flags, the canonical
-    recipe's seven (the client's own environment is creation_env(), an allow-list: whatever client starts a server
+    recipe's eight (the client's own environment is creation_env(), an allow-list: whatever client starts a server
     hands its environment to every later session there, DEF-1559, DEF-1802). `command` is one shell-command string,
     run by the server's default shell like the recipe's command."""
     trace = lane_trace(lane_id, ws)
@@ -319,7 +323,7 @@ def new_session_argv(socket, session, cwd, lane_id, ws, command):
             '-e', f'LANE_ID={lane_id}', '-e', f'LANE_WS={ws}',
             '-e', f'ANTHROPIC_CUSTOM_HEADERS=x-throttle-trace: {trace}', '-e', f'THROTTLE_TRACE={trace}',
             '-e', f'KIMI_CODE_CUSTOM_HEADERS=x-throttle-trace: {trace}', '-e', f'LANES_TRACE={trace}',
-            '-e', f'GROK_HOME={GROK_HOME}', command]
+            '-e', f'GROK_HOME={GROK_HOME}', '-e', f'MUSE_CUSTOM_HEADERS=x-throttle-trace: {trace}', command]
 
 
 CREATION_ENV = ('HOME', 'USER', 'LOGNAME', 'PATH', 'LANG', 'LANGUAGE', 'TZ', 'TMUX_TMPDIR')   # and every LC_*
@@ -392,9 +396,9 @@ def lane_trace(lane_id, ws):
 
 def canonical_recipe(lane_id, ws, socket, session, folder, cmd='bash -l'):
     """lanes_lib.canonical_recipe: the create recipe that gives a new tmux lane its identity (LANE_ID, LANE_WS, the
-    lanes/<ws>/<id> trace as ANTHROPIC_CUSTOM_HEADERS, THROTTLE_TRACE, KIMI_CODE_CUSTOM_HEADERS and LANES_TRACE, and
-    GROK_HOME) through `-e` flags; `new -A` attaches when the session exists. LaneError where the host raises
-    LanesError."""
+    lanes/<ws>/<id> trace as ANTHROPIC_CUSTOM_HEADERS, THROTTLE_TRACE, KIMI_CODE_CUSTOM_HEADERS, LANES_TRACE and (W13)
+    MUSE_CUSTOM_HEADERS, and GROK_HOME) through `-e` flags; `new -A` attaches when the session exists. LaneError where
+    the host raises LanesError."""
     trace = lane_trace(lane_id, ws)
     if trace is None:
         raise LaneError(f'Invalid lane trace: lanes/{ws}/{lane_id} (allowed: A-Z a-z 0-9 . _ - /, at most 256)',
@@ -411,7 +415,7 @@ def canonical_recipe(lane_id, ws, socket, session, folder, cmd='bash -l'):
     return (f'tmux -L {shlex.quote(socket)} new -ADs {shlex.quote(session)} -c {shlex.quote(folder)} '
             f'-e LANE_ID={lane_id} -e LANE_WS={ws} -e ANTHROPIC_CUSTOM_HEADERS={header} '
             f'-e THROTTLE_TRACE={trace} -e KIMI_CODE_CUSTOM_HEADERS={header} -e LANES_TRACE={trace} '
-            f'-e GROK_HOME={GROK_HOME} {cmd}')
+            f'-e GROK_HOME={GROK_HOME} -e MUSE_CUSTOM_HEADERS={header} {cmd}')
 
 
 def lane_name_problem(name):
@@ -486,8 +490,10 @@ def lane_kind(entry):
 
 # The harnesses a process tree can name (W12; lane-signal's HARNESS_COMMS and parent chain, pinned equal by
 # test_lane_core). A `grok` is Grok Build when its executable is $GROK_HOME/downloads/grok-linux-x86_64, else grok-cli.
-HARNESS_COMMS = {'claude': 'claude', 'codex': 'codex', 'kimi': 'kimi', 'kimi-code': 'kimi', 'grok': 'grok'}
-HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'unknown')
+HARNESS_COMMS = {'claude': 'claude', 'codex': 'codex', 'kimi': 'kimi', 'kimi-code': 'kimi', 'grok': 'grok',
+                 'muse': 'muse', 'zcode-cli': 'zcode'}
+HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'muse', 'zcode', 'unknown')
+MUSE_PREFIX = 'muse-bin-'   # W13: Muse Code's comm and binary file name start with it (MEASURED: muse-bin-1.4.10)
 GROK_BUILD_EXE = '/downloads/grok-linux-x86_64'
 CLAUDE_EXE = '/claude/versions/'   # native Claude Code before 2.1.299 kept its file's name, the version, as comm (MEASURED)
 PARENT_DEPTH = 8
@@ -515,15 +521,23 @@ def _exe(proc, pid):
 
 
 def process_harness(proc, pid):
-    """The harness process `pid` is, or None: its comm in HARNESS_COMMS (a `grok` split by /proc/<pid>/exe), else a
-    native Claude Code file (CLAUDE_EXE) as its executable."""
+    """The harness process `pid` is, or None: its comm in HARNESS_COMMS (a `grok` split by /proc/<pid>/exe), a comm
+    starting MUSE_PREFIX (Muse Code), else by its executable: a native Claude Code file (CLAUDE_EXE) or a Muse binary
+    (a file name starting MUSE_PREFIX)."""
     found = _stat(proc, pid)
     if not found:
         return None
     harness = HARNESS_COMMS.get(found[0])
     if harness == 'grok':
         return 'grok' if _exe(proc, pid).endswith(GROK_BUILD_EXE) else 'grok-cli'
-    return harness or ('claude' if CLAUDE_EXE in _exe(proc, pid) else None)
+    if harness:
+        return harness
+    if found[0].startswith(MUSE_PREFIX):
+        return 'muse'
+    exe = _exe(proc, pid)
+    if CLAUDE_EXE in exe:
+        return 'claude'
+    return 'muse' if exe.rpartition('/')[2].startswith(MUSE_PREFIX) else None
 
 
 def parent_harness(proc, pid):
@@ -1013,13 +1027,16 @@ def terminals_add(text, terminal, entry=None):
 MCP_NAME = 'lanes'
 MCP_COMMAND = LZ + '/bin/lane-mcp'
 MCP_ENTRY = {'command': MCP_COMMAND}
-MCP_AGENTS = ('claude', 'codex', 'kimi', 'grok', 'grok-cli')
+MCP_AGENTS = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'muse', 'zcode')
 MCP_FILES = {'claude': '.claude.json', 'codex': '.codex/config.toml', 'kimi': '.kimi-code/mcp.json',
-             'grok': '.grok-build/config.toml', 'grok-cli': '.grok/user-settings.json'}
+             'grok': '.grok-build/config.toml', 'grok-cli': '.grok/user-settings.json',
+             'muse': '.config/muse/settings.json', 'zcode': '.zcode/cli/config.json'}
 # W12: claude and codex get their entry in every home; kimi, grok (Grok Build, GROK_HOME) and grok-cli only where their
-# home directory already is a real directory (the harness is installed there), unless named (`--agent`).
+# home directory already is a real directory (the harness is installed there), unless named (`--agent`). W13: muse
+# (Muse Code's ~/.config/muse, where its auth.json and settings.json live) and zcode (~/.zcode) the same way.
 MCP_ALWAYS = ('claude', 'codex')
-MCP_HOMES = {'kimi': '.kimi-code', 'grok': '.grok-build', 'grok-cli': '.grok'}
+MCP_HOMES = {'kimi': '.kimi-code', 'grok': '.grok-build', 'grok-cli': '.grok', 'muse': '.config/muse',
+             'zcode': '.zcode'}
 TOML_HEADER = re.compile(r'''^[ \t]*\[[ \t]*mcp_servers[ \t]*\.[ \t]*(?:lanes|"lanes"|'lanes')[ \t]*\][ \t]*(?:#.*)?$''')
 # What Codex must hand lane-mcp. Codex starts a stdio MCP server with a CLEARED environment: its defaults (HOME,
 # LOGNAME, PATH, SHELL, USER, LANG, LC_ALL, TERM, TMPDIR, TZ) plus the names in the table's `env_vars` and the
@@ -1380,11 +1397,118 @@ def grok_cli_mcp(text, command=MCP_COMMAND):
     return after, None
 
 
-MCP_EDITORS = {'claude': claude_mcp, 'codex': codex_mcp, 'kimi': kimi_mcp, 'grok': grok_mcp, 'grok-cli': grok_cli_mcp}
+# W13: Muse Code (muse 1.4.10) reads its user settings from ~/.config/muse/settings.json, a JSON object that must say
+# "schema_version": 1 (MEASURED 2026-10-16: a file without it is refused by Muse). An MCP server is `mcp_servers.<name>`
+# {transport, command, args, env, mode}; Muse starts a stdio server with an environment CLEARED to a few names (HOME,
+# PATH, TERM, LANG, MUSE_SESSION_ID) plus the entry's `env`, whose values interpolate `${VAR}` and `${VAR:-}` from
+# Muse's own environment (MEASURED 2026-10-16: `${LANE_ID:-}` arrived as the lane id, `${NOPE:-}` as empty). `mode`
+# defaults to "required", which aborts the session when the server cannot start: ours is "optional".
+MUSE_SCHEMA_VERSION = 1
+MUSE_MCP_ENV = {name: '${' + name + ':-}' for name in MCP_ENV_VARS}
+
+
+def muse_mcp_entry(command=MCP_COMMAND):
+    return {'transport': 'stdio', 'command': command, 'args': [], 'env': dict(MUSE_MCP_ENV), 'mode': 'optional'}
+
+
+def muse_settings_doc(text, what='~/.config/muse/settings.json'):
+    """(doc, why) of Muse Code's settings.json text: a new document when there is none; `why` when the file is not one
+    Lanes may edit (not an object, or no "schema_version": 1 — a file Muse itself would refuse, or a newer schema)."""
+    if text is None or not text.strip():
+        return {'schema_version': MUSE_SCHEMA_VERSION}, None
+    doc = strict_json(text, what)
+    if not isinstance(doc, dict):
+        return None, f'{what} is not a JSON object — left alone'
+    if doc.get('schema_version') != MUSE_SCHEMA_VERSION or isinstance(doc.get('schema_version'), bool):
+        return None, (f'{what} does not say "schema_version": {MUSE_SCHEMA_VERSION} — left alone (Muse Code refuses '
+                      'such a file; fix it by hand first)')
+    return doc, None
+
+
+def muse_mcp(text, command=MCP_COMMAND):
+    """~/.config/muse/settings.json with `mcp_servers.lanes` = muse_mcp_entry() -> (new text, why). A new file is
+    {"schema_version": 1, "mcp_servers": {"lanes": …}}; an existing one must already say schema_version 1. An equal
+    entry is present; an earlier install's (a lane-mcp at another path or with other env) is replaced; a `lanes`
+    server that starts something else is left alone. The edit is that one member, every other byte kept, and the
+    result must parse back to the input plus that member."""
+    what = '~/.config/muse/settings.json'
+    entry = muse_mcp_entry(command)
+    doc, why = muse_settings_doc(text, what)
+    if why:
+        return text, why
+    if text is None or not text.strip():
+        return json.dumps(dict(doc, mcp_servers={MCP_NAME: entry}), indent=2) + '\n', None
+    servers = doc.get('mcp_servers')
+    if servers is not None and not isinstance(servers, dict):
+        return text, f'mcp_servers in {what} is not an object — left alone'
+    current = (servers or {}).get(MCP_NAME)
+    if current == entry:
+        return text, None
+    if current is not None and not _an_older_ours(current):
+        shown = current.get('command') if isinstance(current, dict) else current
+        return text, (f'mcp_servers.{MCP_NAME} in {what} is not the entry Lanes writes (command {shown!r}) — left '
+                      'alone (remove it to let Lanes add its own)')
+    if servers is None:
+        after = set_member(text, [], 'mcp_servers', {MCP_NAME: entry})
+    else:
+        after = set_member(text, ['mcp_servers'], MCP_NAME, entry)
+    if strict_json(after, what) != dict(doc, mcp_servers=dict(servers or {}, **{MCP_NAME: entry})):
+        return text, 'the entry could not be added without changing anything else — add it by hand'
+    return after, None
+
+
+# W13: ZCode CLI (zai-org/ZCode, apps/zcode-cli 0.16.9; READ in its README, not run here) reads MCP servers from
+# ~/.zcode/cli/config.json `mcp.servers.<name>`; a stdio server {type, command, args, cwd, env, enabled, timeoutMs}
+# inherits ZCode's own environment, so the lane's variables arrive without an `env`. `features.mcp` false turns MCP off.
+def _zcode_ours(entry, command):
+    """A ZCode server entry that starts this lane-mcp (its `enabled` and `timeoutMs` are the person's)."""
+    return isinstance(entry, dict) and entry.get('command') == command and not entry.get('args') \
+        and entry.get('type', 'stdio') == 'stdio' and 'url' not in entry
+
+
+def zcode_mcp(text, command=MCP_COMMAND):
+    """~/.zcode/cli/config.json with `mcp.servers.lanes` = {"type": "stdio", "command": <command>} -> (new text, why).
+    A file whose `features.mcp` is false (the person turned MCP off) is left alone, as is a `lanes` server that starts
+    something else; an earlier install's lane-mcp at another path is replaced. The edit is one member, every other byte
+    kept (the file may hold provider headers), and the result must parse back to the input plus that member."""
+    what = '~/.zcode/cli/config.json'
+    entry = {'type': 'stdio', 'command': command}
+    if text is None or not text.strip():
+        return json.dumps({'mcp': {'servers': {MCP_NAME: entry}}}, indent=2) + '\n', None
+    doc = strict_json(text, what)
+    if not isinstance(doc, dict):
+        return text, f'{what} is not a JSON object — left alone'
+    features = doc.get('features')
+    if isinstance(features, dict) and features.get('mcp') is False:
+        return text, f'features.mcp is false in {what} — MCP is off there; left alone'
+    mcp = doc.get('mcp')
+    servers = mcp.get('servers') if isinstance(mcp, dict) else None
+    if (mcp is not None and not isinstance(mcp, dict)) or (servers is not None and not isinstance(servers, dict)):
+        return text, f'mcp.servers in {what} is not an object — left alone'
+    current = (servers or {}).get(MCP_NAME)
+    if _zcode_ours(current, command):
+        return text, None
+    if current is not None and not _an_older_ours(current):
+        shown = current.get('command') if isinstance(current, dict) else current
+        return text, (f'mcp.servers.{MCP_NAME} in {what} is not the entry Lanes writes (command {shown!r}) — left '
+                      'alone (remove it to let Lanes add its own)')
+    if mcp is None:
+        after = set_member(text, [], 'mcp', {'servers': {MCP_NAME: entry}})
+    elif servers is None:
+        after = set_member(text, ['mcp'], 'servers', {MCP_NAME: entry})
+    else:
+        after = set_member(text, ['mcp', 'servers'], MCP_NAME, entry)
+    if strict_json(after, what) != dict(doc, mcp=dict(mcp or {}, servers=dict(servers or {}, **{MCP_NAME: entry}))):
+        return text, 'the entry could not be added without changing anything else — add it by hand'
+    return after, None
+
+
+MCP_EDITORS = {'claude': claude_mcp, 'codex': codex_mcp, 'kimi': kimi_mcp, 'grok': grok_mcp, 'grok-cli': grok_cli_mcp,
+               'muse': muse_mcp, 'zcode': zcode_mcp}
 
 
 def mcp_agents(home):
-    """The agents whose entry an install writes by default: MCP_ALWAYS, plus each of kimi, grok and grok-cli whose
+    """The agents whose entry an install writes by default: MCP_ALWAYS, plus each of kimi, grok, grok-cli, muse and zcode whose
     home directory (MCP_HOMES) is a real directory under `home` — never a link (the host writes through the volume)."""
     found = list(MCP_ALWAYS)
     for agent in MCP_AGENTS:

package/payload/lanes/container/throttle-pulse

@@ -18,10 +18,10 @@ and writes ~/.lz/state/throttle.json (the shape below, by rename) only when a va
 since the file's `at` — `at` is the liveness heartbeat lanes-statusd ages:
 
   {"v": 1, "at": <epoch s>, "up": bool, "tokened": bool,
-   "pools": {"claude"|"codex"|"kimi": {"configured", "usable", "cooling", "exhausted", "benched", "auth_failed",
+   "pools": {"claude"|"codex"|"kimi"|"muse-code"|"zai": {"configured", "usable", "cooling", "exhausted", "benched", "auth_failed",
              "overflow_ready", "pressure_phase", "spill_fraction", "overflow_in_flight", "upstream_429_total",
              "worst_7d", "worst_5h", "soonest_reset"}},
-   "overflow": {"claude"|"codex"|"kimi": {"spend_today_usd", "budget_usd", "fraction", "alert_level_pct"}},
+   "overflow": {"claude"|"codex"|"kimi"|"muse-code"|"zai": {"spend_today_usd", "budget_usd", "fraction", "alert_level_pct"}},
    "error": null | "<why the daemon did not answer>"}
 
 `cooling` is the remainder configured − usable − exhausted − auth_failed − disabled − billing/org-blocked − unhealthy,
@@ -36,7 +36,10 @@ POOLS are claude, codex and (W12, Lanes 1.5.0) kimi: the daemon's `/pools/:pool/
 generic (`src/proxy.rs` `scoped_pool_state`), and a daemon with no Kimi account answers `/pools/kimi/ready` with
 `configured_subscriptions: 0` — a pool with nothing configured, not a failure. Kimi has no paid overflow lane (the
 daemon keeps its `api_overflow` at the default, and its /status still renders a zero overflow block), so only
-MONEY_POOLS carry overflow money: `overflow.kimi` is always nulls.
+MONEY_POOLS carry overflow money: `overflow.kimi` is always nulls. W13 (Lanes 1.6.0) adds Throttle's native `muse-code`
+(Meta's Muse Code, listener 8097) and `zai` (Z.ai, listener 8098) subscription pools on the same generic routes; like
+Kimi their overflow is refused by the daemon's config, so their overflow is always nulls too, and their accounts'
+providers are `muse-code` and `zai` (Throttle's Provider names).
 
 GET only, 3 s timeout, 1 MiB body cap, no redirect followed (one would carry the bearer elsewhere), no proxy from the
 environment. Stdlib only. Exit: --once 0 when the daemon answered, 1 when not, 2 on a usage error; --loop runs until
@@ -62,12 +65,12 @@ TIMEOUT = 3                  # seconds per GET
 MAX_BODY = 1 << 20           # bytes: a bigger answer is not the daemon's
 TOKEN_MAX = 4096             # bytes: a token file is one short line
 DEFAULT_PORT = 19181
-POOLS = ('claude', 'codex', 'kimi')
-MONEY_POOLS = frozenset({'claude', 'codex'})   # the pools with a paid overflow lane; kimi's money is always null
+POOLS = ('claude', 'codex', 'kimi', 'muse-code', 'zai')
+MONEY_POOLS = frozenset({'claude', 'codex'})   # the pools with a paid overflow lane; kimi/muse-code/zai money: null
 # The gauge's numbers (src/proxy.rs render_metrics: 0=calm,1=spilling,2=elevated) as the words the daemon's own JSON
 # uses for them (src/pressure.rs PressureSnapshot.phase: "closed" is calm), which economy.json and the sidebar read.
 PHASES = {0: 'closed', 1: 'spilling', 2: 'elevated'}
-SUBSCRIPTION_PROVIDERS = frozenset({'anthropic', 'openai', 'kimi'})   # src/proxy.rs is_subscription_provider
+SUBSCRIPTION_PROVIDERS = frozenset({'anthropic', 'openai', 'kimi', 'muse-code', 'zai'})   # src/proxy.rs is_subscription_provider
 SERIES = {'throttle_pool_spill_fraction': 'spill_fraction', 'throttle_overflow_in_flight': 'overflow_in_flight',
           'throttle_upstream_429_total': 'upstream_429_total', 'throttle_pool_pressure_phase': 'pressure_phase'}
 POOL_KEYS = ('configured', 'usable', 'cooling', 'exhausted', 'benched', 'auth_failed', 'overflow_ready',

package/payload/lanes/docs/ARCHITECTURE.md

@@ -70,14 +70,17 @@ for operations, the [runbook](RUNBOOK.md).
 
    **The harness is observed (W12, Lanes 1.5.0; spec
    `docs/superpowers/specs/2026-10-15-lanes-harness-observers-design.md`; DM-LANES-STATUS, DM-LANES-CONTAINER-STATUS).**
-   `agent.harness` is one of `claude | codex | kimi | grok | grok-cli | shell | unknown` (`shell` is the walk's word for a
+   `agent.harness` is one of `claude | codex | kimi | grok | grok-cli | muse | zcode | shell | unknown` (W13 added `muse`
+   and `zcode`; `shell` is the walk's word for a
    pane and never reaches a published `agent{}`), an OBSERVED fact read from
    the pane's process tree, not a side effect of which title parser matched: `agent_state.harness_walk` reads
    `/proc/<pane pid>/task/*/children` (the reads `pane_has_child` already makes) and each process's `comm` in the
    container's /proc, breadth first from the pane's root down four levels and at most 64 processes, and the first
    process whose comm is `claude`, `codex`, `kimi`/`kimi-code` or `grok` — or whose `/proc/<pid>/exe` holds
    `/claude/versions/`, native Claude Code before 2.1.299 running with its version (`2.1.295`) as comm (DEF-1993) —
-   names it. Codex runs as `bash` → `node` → `codex`, so it is found one level down; two `grok` binaries are told
+   names it; since W13 also `muse` (Muse Code's launcher script), `zcode-cli` (ZCode's process title), a comm starting
+   `muse-bin-` (MEASURED: `muse-bin-1.4.10`, the cut of `muse-bin-1.4.10-R6427.1`) or an exe whose file name does.
+   Codex runs as `bash` → `node` → `codex`, so it is found one level down; two `grok` binaries are told
    apart by `/proc/<pid>/exe`: `…/downloads/grok-linux-<arch>` is Grok Build (the rule of
    `harness_grok.harness_of_exe`; the container walks of `lane-signal` and `lane_core` match
    `/downloads/grok-linux-x86_64`, the one arch measured), anything else grok-cli, an unreadable link `unknown`. Only
@@ -139,12 +142,33 @@ for operations, the [runbook](RUNBOOK.md).
    it reaches `agent{}` only through the hook sidecar (DEF-1980). The Grok Build file shapes come from its source and
    user guide; no logged-in session was measured yet (DEF-1981).
 
+   **Muse Code and ZCode** (W13, Lanes 1.6.0; spec
+   `docs/superpowers/specs/2026-10-16-lanes-harness-observers-muse-zcode-design.md`; `libexec/harness_muse.py`).
+   `agent_state.muse_sessions(root, panes, *, home, now)` forwards to `harness_muse.muse_sessions` (looked up at the
+   call like `harness_grok`); `statusd.agent_signals` passes {pane key: Muse pid} for every pane its walk observed as
+   `muse`. The join: the pane's Muse pid holds its session's `.session.lock` open (at most 512 fd links read; the
+   link must end `…/sessions/YYYY/MM/DD/<id>/.session.lock`, never a subagent's), the lock file names `pid=<pid>`
+   (a lock naming another pid is not this pane's); else the runtime registry's `process_generation_hint` `pid=<pid>`
+   and the newest 31 day directories searched for that id. Then the last 64 KiB of `session.jsonl`, whole lines only:
+   `runtime.user_intent.accepted` or run `started` → `working`; other in-run records keep it (a hook's run is no turn);
+   run `terminal` completed / cancelled → `needs_input`, failed → `errored`; `run_retracted` → `needs_input`; no turn
+   in a whole file → `idle`; `session.end` → no claim; a session older than an hour → no claim. The prompt the accepted
+   and `started` records carry is never read into a verdict (customer content). `session.name.changed` is the name (read from the log's first 32 KiB when the tail holds none: Muse names a session
+   near its start).
+   Verdict: `harness: muse`, `source: muse-session-file`, the session id, the Muse pid. `merge`'s order: sidecar >
+   Claude file > Kimi file > Muse file > Grok observer > Grok title > Muse title (`harness_muse.parse_muse_title`:
+   `⠙ <folder>` working, `<folder>` idle, `source: muse-title`) > Codex title > process. Muse and ZCode ring no bell
+   (`agent_state.BELL_LESS`): no rung turns their verdict into `done`. ZCode keeps sessions in SQLite and draws no
+   title: it reaches `agent{}` through its process (`zcode` / `idle`) and its hooks only. The approval records of
+   Muse's log were not captured (DEF-2057): the observer reads `needs_approval` only from a record kind that names an
+   approval or permission being asked.
+
    What is published is not `merge`'s word itself but its debounced form, `agent_state.settle`, with three more
    additive keys (`raw_status`, `raw_since`, `stable_since`): see [Attention queue](#attention-queue).
 
    The hook sidecar is `~/.lz/state/hooks/<lane id>.json` in the container, written by `~/.lz/bin/lane-signal`
    (Python 3 stdlib, installed by `lanes install-container`) when an opt-in hook fires (Claude Code, Codex, Kimi
-   Code, Grok Build, grok-cli): `{v: 1, lane, harness, status, since, at, event, pid, start, session}` — `since` when the status began (kept
+   Code, Grok Build, grok-cli, Muse Code, ZCode): `{v: 1, lane, harness, status, since, at, event, pid, start, session}` — `since` when the status began (kept
    while the same status is re-signalled), `at` the last event, `pid`/`start` the agent process and its
    starttime — plus `name`, the agent's own note when it reported one (`lanes_signal`, LNS-35: kept while the status
    repeats, dropped when it changes). A report (`event: lanes_signal`) stands against the same agent's hooks — the
@@ -161,14 +185,19 @@ for operations, the [runbook](RUNBOOK.md).
    container `lane ls` read (DEF-1572). A zmx lane's sidecar is therefore named by its zmx session, not by the
    `<ws>--z-<name>` id statusd publishes, and does not reach that lane's `agent{}` yet — the zmx lane's `agent` key
    stays lane-run's record (DEF-1573). A published sidecar adds `event` to `agent{}` and has `source: hook`. Hooks are
-   never installed implicitly: `lanes hooks install --agent claude|codex|kimi|grok|grok-cli --container <name>`
+   never installed implicitly: `lanes hooks install --agent claude|codex|kimi|grok|grok-cli|muse|zcode --container <name>`
    prints the merge and writes only with `--write` (RUNBOOK "Installing agent hooks" and "Harnesses").
 
    **The container side** (W12 Track C). `lane-signal`'s default harness is `--harness`, else `LANE_HARNESS`, else
    the parent processes' (`comm` in the same set, a `grok` split by its exe, a native Claude Code file by its exe),
    else `unknown` — never `codex`; `lane-mcp` names the client's harness from its MCP client name (`claude`, `codex`,
-   `kimi-code`/`kimi`, `grok-shell-*` → `grok`, `grok-cli*` → `grok-cli`), else the parent rule. The per-harness
-   operator steps are RUNBOOK "Harnesses"; what a person sees, the user guide's "Harnesses".
+   `kimi-code`/`kimi`, `grok-shell-*` → `grok`, `grok-cli*` → `grok-cli`; W13: `tbh` → `muse`, `zcode*` → `zcode`),
+   else the parent rule. W13: when a hook arrives with neither `LANE_ID` nor `TMUX` (Muse Code clears its hooks'
+   environment), `lane-signal` reads `LANE_ID`, `LANE_WS`, `TMUX` and `TMUX_PANE` from the agent's own
+   `/proc/<pid>/environ` — only for a pid that is a known harness, bounded, never through a link: the rule of
+   `lane_core.parent_environ`, pinned equal by `test_harness_w13.SignalIdentityFallback` (DEF-2031); a
+   `PostToolUseFailure` with `is_interrupt: true` is `needs_input` (ZCode runs no Stop after an interrupt, DEF-2091).
+   The per-harness operator steps are RUNBOOK "Harnesses"; what a person sees, the user guide's "Harnesses".
 
    **Fleet and Throttle facts** (W11, spec `docs/superpowers/specs/2026-10-11-lanes-fleet-dashboard-design.md` §2;
    DM-LANES-THROTTLE-PULSE, DM-LANES-FLEET). Two additive `status.json` keys feed the sidebar's fleet block and
@@ -178,15 +207,16 @@ for operations, the [runbook](RUNBOOK.md).
    its container's `127.0.0.1` (DEF-1525), so the host cannot poll it. `~/.lz/bin/throttle-pulse` (a contract file,
    Python 3 stdlib) runs as a loop only in the daemon's container — site.conf `LANES_THROTTLE_CONTAINER`, else the
    container of the registry's `tools--throttle-monitor` tab — where `lanes install-container` starts it, once, as
-   `tmux -L lanes-pulse` session `pulse`. Every 10 s it GETs the open `/pools/{claude,codex,kimi}/ready` and
-   `/metrics`, and the guarded `/pools/{claude,codex,kimi}/status` only with the bearer the operator adopted into
+   `tmux -L lanes-pulse` session `pulse`. Every 10 s it GETs the open `/pools/{claude,codex,kimi,muse-code,zai}/ready` and
+   `/metrics`, and the guarded `/pools/{claude,codex,kimi,muse-code,zai}/status` only with the bearer the operator adopted into
    `~/.lz/throttle-token` (`lanes throttle adopt-token`; the control port has no loopback exemption, DEF-1930), and
    writes `~/.lz/state/throttle.json` by rename when a value changed or 60 s passed — never anything else, never a
    POST (RUNBOOK "Throttle pulse"). The kimi pool (W12) rides the daemon's generic pool routes (`scoped_pool_state`):
    a daemon with no Kimi account reports it with nothing configured, and since Kimi has no paid overflow lane its
-   `overflow` is always null (`MONEY_POOLS` is claude and codex). The sidebar draws one provider row per pool —
-   `◆ anthropic`, `◆ openai`, `◆ moonshot` — so the full block is a rule and six rows from 25 pane rows
-   (`FLEET_FULL`), and the three-row form shows the pool with the smallest usable share, a pool with nothing
+   `overflow` is always null (`MONEY_POOLS` is claude and codex). W13 adds Throttle's native `muse-code` and `zai`
+   pools the same way (no paid overflow either: their overflow is null too). The sidebar draws one provider row per
+   pool — `◆ anthropic`, `◆ openai`, `◆ moonshot`, `◆ meta`, `◆ z.ai` — so the full block is a rule and eight rows
+   from 27 pane rows (`FLEET_FULL`), and the three-row form shows the pool with the smallest usable share, a pool with nothing
    configured never (DEF-2002). There is no Grok row: Throttle has no xAI pool.
 
    *`throttle`.* On every cycle statusd copies that file into `status.json`. It looks the daemon's container up again
@@ -711,6 +741,23 @@ identity so folder permissions work. On Linux it is a systemd user service that
 user manager holds, looked up before every login, so an agent a desktop session hands over after boot is used
 without a restart. The installer's remembered `--no-uploads` / `--no-desktop` remove what an earlier install added.
 
+Desktop `lanes attach` execs `libexec/attach.py`, a PTY supervisor for exactly one Zellij client. It relays raw
+input and output with nonblocking writes, forwards the terminal size, and restores terminal modes on exit.
+`OUTPUT_LIMIT` (1 MiB) and `OUTPUT_AGE` (5 s) bound output waiting for the SSH terminal; no output means no timeout.
+Crossing either bound terminates only its child, with `STOP_GRACE` (1 s) before KILL, and exits 1 for the existing
+`lanes-launch` reconnect loop. The view server, its panes and their tmux/zmx holders remain alive. The existing
+`clients/<device>.<client>.pid` now names the supervisor; its argv still carries the exact Zellij attach command,
+so stale-predecessor cleanup reaches the supervisor and its owned child. No new durable state is introduced.
+
+This closes the desktop failure observed on Anarchy on 2026-10-16 (DEF-1965). In the pinned Zellij 0.45.1,
+[`ClientSender`](https://github.com/zellij-org/zellij/blob/v0.45.1/zellij-server/src/os_input_output.rs) removes a
+client when its 5,000-message queue fills, but sends Exit only after draining queued messages. The
+[`input handler`](https://github.com/zellij-org/zellij/blob/v0.45.1/zellij-client/src/input_handler.rs) can then wait
+indefinitely for an action acknowledgement. The transport remains alive while the display cannot interact.
+The supervisor bounds terminal backpressure before that can strand an attachment; it does not patch upstream
+Zellij or cover its separate browser transport. `tests/attach_backpressure.py` proves the unread-terminal control,
+bounded disconnect, holder survival and keyboard switching after reattachment with the installed pin.
+
 The sidebar sends an upload request naming paths, workspace and device. The client checks its folder allowlist,
 streams an archive over SSH, and reports original errors and progress. The host extracts data into that
 workspace's `uploads/` folder without overwriting files; an optional paste places the resulting paths in the