@vibelord/lanes 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibelord/lanes",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Installer for Lanes: shared agent terminals over SSH with Zellij views, registry sync, uploads and a phone interface.",
   "license": "MIT",
   "type": "module",

package/payload/lanes/README.md

@@ -12,7 +12,7 @@ glyph and command, installation and updates, and the operations reference.
 Closing a view or losing a connection leaves the terminals running in their workspace containers: a lane ends only
 when someone closes it explicitly.
 
-**Who uses it.** Operators and teammates who run several Claude Code, Codex, Kimi Code or Grok agents at once use
+**Who uses it.** Operators and teammates who run several Claude Code, Codex, Kimi Code, Grok, Muse Code or ZCode agents at once use
 Lanes daily to see which lane needs them, switch to it, answer, and move on, from a desk or from a phone (which
 harness runs where, and what Lanes reads from each: [Harnesses](docs/USERGUIDE.md#harnesses)). An administrator installs the
 server once on the workspace host. Any member invites a new person with `lanes invite`, and that person joins from

package/payload/lanes/VERSION

@@ -1 +1 @@
-1.5.0
+1.6.0

package/payload/lanes/bin/lanes

@@ -88,9 +88,10 @@
                                  unknown one stops the run before anything is written); --write then applies, in order:
                                  the board (`workspaces add`, when --workspace is given), install-container,
                                  (--step grok-build first: see below) `hooks install --write` for claude and codex,
-                                 then for kimi, grok (Grok Build) and
-                                 grok-cli where that harness's home (~/.kimi-code, ~/.grok-build, ~/.grok) is in the
-                                 container (else `skipped`); two steps run only when named: --step kimi-notify (Kimi's
+                                 then for kimi, grok (Grok Build), grok-cli, muse (Muse Code) and zcode (ZCode) where
+                                 that harness's home (~/.kimi-code, ~/.grok-build, ~/.grok, ~/.config/muse, ~/.zcode) is
+                                 in the container (else `skipped`; Lanes installs neither Muse nor ZCode); two steps run
+                                 only when named: --step kimi-notify (Kimi's
                                  tui.toml notification_condition = "always": the bell on every turn end) and --step
                                  grok-build (Grok Build installed under GROK_HOME=~/.grok-build by the stable-channel
                                  recipe, never ~/.grok; the channel publishes no checksum, so the receipt records the
@@ -199,9 +200,11 @@
                                  (additive; installs no agent hook and no editor: lane-edit runs $LANES_EDITOR or the
                                  first of micro hx nvim vim vi there) and add the Lanes MCP server to the agents'
                                  configs: mcpServers.lanes in ~/.claude.json and [mcp_servers.lanes] in
-                                 ~/.codex/config.toml, and where Kimi Code, Grok Build or grok-cli is installed
-                                 ~/.kimi-code/mcp.json, ~/.grok-build/config.toml (a `# >>> lanes mcp >>>` block) or
-                                 ~/.grok/user-settings.json (mcp.servers id lanes), all starting
+                                 ~/.codex/config.toml, and where Kimi Code, Grok Build, grok-cli, Muse Code or ZCode is
+                                 installed ~/.kimi-code/mcp.json, ~/.grok-build/config.toml (a `# >>> lanes mcp >>>`
+                                 block), ~/.grok/user-settings.json (mcp.servers id lanes),
+                                 ~/.config/muse/settings.json (mcp_servers.lanes, mode optional) or
+                                 ~/.zcode/cli/config.json (mcp.servers.lanes), all starting
                                  /home/coder/.lz/bin/lane-mcp — only where missing,
                                  the file kept as <file>.bak-<UTC> first, atomic (a `lanes` entry that starts something
                                  else is left alone, exit 1; on a uid split nothing is written there, exit 1). --no-mcp
@@ -218,14 +221,17 @@
                                  must start `throttle_` — into its ~/.lz/throttle-token (0600, by rename), read and
                                  written through /proc/<init>/root without following a link. Prints `adopted` or the
                                  refusal, never the value. Exit 1 when refused
-  lanes hooks install --agent claude|codex|kimi|grok|grok-cli (--container <name> | --home <dir>) [--dry-run | --write]
+  lanes hooks install --agent claude|codex|kimi|grok|grok-cli|muse|zcode (--container <name> | --home <dir>) [--dry-run | --write]
                                  merge the lane-signal hooks into that home's ~/.claude/settings.json or ~/.codex/hooks.json
                                  (+ a top-level Codex notify when none is set), ~/.kimi-code/config.toml (a `# >>> lanes
                                  hooks >>>` block of [[hooks]]), Grok Build's ~/.grok-build/hooks/lanes.json and
                                  ~/.grok-build/config.toml (blocks: [compat.claude] hooks/mcps = false, [ui.notifications]
                                  bel always, [model."grok-4.6"/"grok-4.5"] env_http_headers from LANES_TRACE) or
-                                 grok-cli's ~/.grok/user-settings.json `hooks`; prints the diff (credential values shown
-                                 as …), writes only with --write (backup kept; nothing outside a block is rewritten).
+                                 grok-cli's ~/.grok/user-settings.json `hooks`, Muse Code's ~/.config/muse/settings.json
+                                 `hooks` (schema_version 1 required) or ZCode's ~/.zcode/cli/config.json `hooks.events`
+                                 (+ hooks.enabled true; refused when it is false); prints the diff (credential values
+                                 shown as …), writes only with --write (backup kept; nothing outside a block or the one
+                                 JSON member is rewritten).
                                  Opt-in, per container; Codex still asks you to trust new hooks.
                                  --write into a --container whose home the agent could not read from this account (uid
                                  not 1000, or a home volume not owned by 1000) is refused with the reason
@@ -1127,8 +1133,8 @@ def cmd_attach(args):
     # Record the base and bring the owner (W8 A2) in line, also for sessions that existed before either was known.
     record_base(device, args)
     record_look(device, args)
-    # Views idle until a real client (with a real size) has attached once. We exec into the zellij
-    # client below, so a detached helper raises the flag shortly after the client has sized the session.
+    # Views idle until a real client (with a real size) has attached once. We exec into the display
+    # supervisor below, so a detached helper raises the flag shortly after its client has sized the session.
     ready = L.STATE / 'clients' / f'{device}.ready'
     if not ready.exists() and os.fork() == 0:
         os.setsid()
@@ -1163,7 +1169,11 @@ def cmd_attach(args):
                      'COLORTERM': os.environ.get('COLORTERM', 'truecolor')})
     if L.run_bounded(['infocmp', env['TERM']], 5)[0] != 0:   # unknown here — or no answer: the safe default
         env['TERM'] = 'xterm-256color'
-    os.execve(str(ZELLIJ), ZELLIJ_BASE + ['attach', device], env)
+    # Own the terminal backlog as well as SSH's transport. A slow Zellij 0.45.1
+    # client can stay alive after its server has dropped it (Exit is behind the
+    # queued frames); keepalives alone cannot make lanes-launch reconnect it.
+    os.execve(sys.executable, [sys.executable, str(L.REPO / 'libexec/attach.py'),
+                              *ZELLIJ_BASE, 'attach', device], env)
 
 
 def cmd_open(args):
@@ -1320,7 +1330,7 @@ def cmd_install_container(args):
     # user (0700), never here.
     install_file(L.REPO / 'container/vimrc', root / 'vimrc')
     # The hook DEFINITIONS travel with the contract for reference; no hook is installed here — that is the opt-in,
-    # per-container `lanes hooks install --agent claude|codex|kimi|grok|grok-cli --container <name> --write` (RUNBOOK).
+    # per-container `lanes hooks install --agent claude|codex|kimi|grok|grok-cli|muse|zcode --container <name> --write` (RUNBOOK).
     for source in sorted([*(L.REPO / 'container/hooks').glob('*.json'), *(L.REPO / 'container/hooks').glob('*.toml')]):
         install_file(source, root / 'hooks' / source.name)
     env_file = L.REPO / 'container/env.sh'   # TMPDIR off the RAM-backed /tmp; only NEW shells and agents read it
@@ -1458,13 +1468,16 @@ HOOK_TARGETS = {'claude': ('claude-settings.json', '.claude/settings.json'),
                 'codex': ('codex-hooks.json', '.codex/hooks.json'),
                 'kimi': ('kimi-hooks.toml', '.kimi-code/config.toml'),
                 'grok': ('grok-hooks.json', '.grok-build/hooks/lanes.json'),
-                'grok-cli': ('grok-cli-hooks.json', '.grok/user-settings.json')}
+                'grok-cli': ('grok-cli-hooks.json', '.grok/user-settings.json'),
+                'muse': ('muse-hooks.json', '.config/muse/settings.json'),
+                'zcode': ('zcode-hooks.json', '.zcode/cli/config.json')}
 # The other file an install changes: Codex's top-level notify; Grok Build's config.toml blocks (W12).
 HOOK_EXTRA = {'codex': ('.codex/config.toml',), 'grok': ('.grok-build/config.toml',)}
 # W12: a harness whose home is not a directory in the container is not installed there; `lanes onboard` skips it.
-HOOK_HOMES = {'kimi': '.kimi-code', 'grok': '.grok-build', 'grok-cli': '.grok'}
-HOOKS_USAGE = ('usage: lanes hooks install --agent claude|codex|kimi|grok|grok-cli (--container <name> | --home <dir>) '
-               '[--dry-run | --write]')
+HOOK_HOMES = {'kimi': '.kimi-code', 'grok': '.grok-build', 'grok-cli': '.grok', 'muse': '.config/muse',
+              'zcode': '.zcode'}
+HOOKS_USAGE = ('usage: lanes hooks install --agent claude|codex|kimi|grok|grok-cli|muse|zcode (--container <name> | '
+               '--home <dir>) [--dry-run | --write]')
 
 
 def hook_files(agent):
@@ -1730,9 +1743,79 @@ def grok_cli_settings(text):
     return after
 
 
+# ------------------------------------------------------------------- W13: Muse Code and ZCode hooks
+# Both are JSON files the harness owns, edited without markers: the one member Lanes changes is merged (merge_hooks:
+# every lane-signal group of an earlier install replaced, every other group, event and key kept) and set in place
+# (lane_core.set_member), every other byte kept; the result must parse back to the input with that member.
+
+def muse_settings(text):
+    """Muse Code's ~/.config/muse/settings.json with the lane-signal groups merged into its `hooks` (Claude Code's
+    shape: {Event: [{matcher?, hooks: [{type: "command", command, timeout, async?}]}]}, timeout in seconds; MEASURED
+    2026-10-16 on muse 1.4.10). A new file is {"schema_version": 1, "hooks": …}; an existing one must already say
+    "schema_version": 1 (Muse refuses a file without it). Never registered: LLMCall, Subagent*, PostToolBatch (they
+    carry model content and fire per call); Interrupt runs `async` (Muse requires it). Muse clears a hook's environment,
+    so lane-signal finds the lane through the agent's own /proc environ (DEF-2031)."""
+    core, what = lane_core(), '~/.config/muse/settings.json'
+    ours = render_hooks('muse')
+    try:
+        doc, why = core.muse_settings_doc(text, what)
+    except core.LaneError as error:
+        raise _lane_error(error) from None
+    if why:
+        raise L.LanesError(why)
+    if text is None or not text.strip():
+        return json.dumps(dict(doc, hooks=ours['hooks']), indent=2, ensure_ascii=False) + '\n'
+    merged = merge_hooks(doc, ours)['hooks']
+    if merged == doc.get('hooks'):
+        return text
+    after = core.set_member(text, [], 'hooks', merged)
+    if core.strict_json(after, what) != dict(doc, hooks=merged):
+        raise L.LanesError(f'{what}: the hooks could not be merged without changing anything else — add them by hand')
+    return after
+
+
+def zcode_config(text):
+    """ZCode's ~/.zcode/cli/config.json with `hooks.enabled` true and the lane-signal groups merged into
+    `hooks.events` (its README: process hooks {type: "process", command, args, timeoutMs}, argv execution without a
+    shell, so the command is lane-signal's absolute path; hooks are off by default). A file whose `hooks.enabled` is
+    explicitly false refuses: the person turned hooks off, and Lanes does not turn them on behind them. Every other key
+    of `hooks` (timeoutMs, maxOutputBytes) stays."""
+    core, what = lane_core(), '~/.zcode/cli/config.json'
+    ours = render_hooks('zcode')
+    if text is None or not text.strip():
+        return json.dumps({'hooks': {'enabled': True, 'events': ours['hooks']}}, indent=2, ensure_ascii=False) + '\n'
+    try:
+        doc = core.strict_json(text, what)
+    except core.LaneError as error:
+        raise _lane_error(error) from None
+    if not isinstance(doc, dict):
+        raise L.LanesError(f'{what}: not a JSON object — refusing to rewrite it')
+    hooks = doc.get('hooks')
+    if hooks is not None and not isinstance(hooks, dict):
+        raise L.LanesError(f'{what}: "hooks" is not an object — fix it by hand first')
+    if isinstance(hooks, dict) and hooks.get('enabled') is False:
+        raise L.LanesError(f'{what}: hooks.enabled is false — someone turned ZCode hooks off; left alone (set it to '
+                           'true by hand, then run this again)')
+    events = (hooks or {}).get('events', {})
+    merged = merge_hooks({'hooks': events}, ours)['hooks']
+    wanted = dict(hooks or {}, enabled=True, events=merged)
+    if wanted == hooks:
+        return text
+    if hooks is None:
+        after = core.set_member(text, [], 'hooks', wanted)
+    else:
+        after = core.set_member(text, ['hooks'], 'enabled', True)
+        after = core.set_member(after, ['hooks'], 'events', merged)
+    if core.strict_json(after, what) != dict(doc, hooks=wanted):
+        raise L.LanesError(f'{what}: the hooks could not be merged without changing anything else — add them by hand')
+    return after
+
+
 HOOK_EDITORS = {'kimi': (('.kimi-code/config.toml', kimi_config),),
                 'grok': (('.grok-build/hooks/lanes.json', grok_hooks_file), ('.grok-build/config.toml', grok_config)),
-                'grok-cli': (('.grok/user-settings.json', grok_cli_settings),)}
+                'grok-cli': (('.grok/user-settings.json', grok_cli_settings),),
+                'muse': (('.config/muse/settings.json', muse_settings),),
+                'zcode': (('.zcode/cli/config.json', zcode_config),)}
 
 
 def install_edits(home, edits, write):
@@ -2744,7 +2827,8 @@ def cmd_workspaces(args):
 ONBOARD_USAGE = ('usage: lanes onboard <login> --container <name> [--workspace <id> --repo <path> [--title T]] '
                  '[--write] [--no-mcp] [--step kimi-notify|grok-build]...')
 ONBOARD_OPTIONAL = ('kimi-notify', 'grok-build')   # steps that run only when named with --step (W12)
-HARNESS_NAMES = {'kimi': 'Kimi Code', 'grok': 'Grok Build', 'grok-cli': 'grok-cli'}
+HARNESS_NAMES = {'kimi': 'Kimi Code', 'grok': 'Grok Build', 'grok-cli': 'grok-cli', 'muse': 'Muse Code',
+                 'zcode': 'ZCode'}
 # The receipt's status vocabulary. A dry run reports planned, unchanged, skipped, manual or failed, and `ok` for the
 # read-only `inspect` of the container; `manual` names a step a person still has to take (printed with the exact command);
 # `warn` is a step that ran and reported a problem that does not stop onboarding (the doctor's verdict, a board with
@@ -3225,6 +3309,7 @@ def cmd_onboard(args):
             ('lane-mcp', mcp_step, False), ('hooks-claude', hooks_step('claude'), False),
             ('hooks-codex', hooks_step('codex'), False), ('hooks-kimi', hooks_step('kimi'), False),
             ('kimi-notify', kimi_notify_step, False), ('hooks-grok', hooks_step('grok'), False), ('hooks-grok-cli', hooks_step('grok-cli'), False),
+            ('hooks-muse', hooks_step('muse'), False), ('hooks-zcode', hooks_step('zcode'), False),
             ('throttle', lambda: provision_throttle(container, site, write), False),
             ('sync', sync_step, False), ('cursor-sync', cursor_step, False), ('resync', resync_step, False),
             ('doctor', doctor_step, False)]
@@ -4795,10 +4880,10 @@ def docs_doctor(home=None, probe=None):
 # statusd calls it stale past 90 s (statusd.PULSE_STALE_S, DEF-1941), and doctor's own clock uses the same bound, so the
 # two never disagree about a healthy pulse.
 PULSE_FRESH_S = 90
-# The pulse's pools in its order (statusd.PULSE_POOLS, the throttle-pulse POOLS; W12 added kimi), named by the
-# `throttle pools:` line. A pool the pulse did not report says `?`: a pulse from before 1.5.0, or a daemon from before
-# its Kimi pool (`/pools/kimi/ready` answers 404 there).
-PULSE_POOLS = ('claude', 'codex', 'kimi')
+# The pulse's pools in its order (statusd.PULSE_POOLS, the throttle-pulse POOLS; W12 added kimi, W13 muse-code and zai),
+# named by the `throttle pools:` line. A pool the pulse did not report says `?`: a pulse from before 1.5.0 (1.6.0 for
+# muse-code and zai), or a daemon from before that pool (`/pools/<pool>/ready` answers 404 there).
+PULSE_POOLS = ('claude', 'codex', 'kimi', 'muse-code', 'zai')
 FLEET_FRESH_S = 60          # statusd republishes `fleet` every FLEET_INTERVAL (10 s) unless the host is critical
 THROTTLE_MONITOR = 'tools--throttle-monitor'
 FLEET_DASHBOARD_KEY = 'LANES_FLEET_DASHBOARD_URL'
@@ -4969,11 +5054,12 @@ def fleet_doctor(status, registry, home=None, now=None):
 # value of the spec's enum, `unknown` (and any value outside the enum, such as an empty harness from a statusd before
 # W12) only when some lane has it. A row without `agent` (no signal names an agent there) is not counted. Information
 # only, never a ✗.
-HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'shell')
+HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'muse', 'zcode', 'shell')   # W13: + muse, zcode
 
 
 def harness_line(status):
-    """`lanes: claude 50 · codex 20 · kimi 3 · grok 0 · grok-cli 0 · shell 0` from status.json's lane rows. `shell`
+    """`lanes: claude 50 · codex 20 · kimi 3 · grok 0 · grok-cli 0 · muse 0 · zcode 0 · shell 0` from status.json's
+    lane rows. `shell`
     counts an agent{} that names it, which statusd's merge never writes (a pane whose harness ended is published under
     that harness's name with status `shell`, DM-LANES-STATUS): the slot reads 0 unless a foreign sidecar says so."""
     counts, unknown = dict.fromkeys(HARNESSES, 0), 0

package/payload/lanes/client/ghostty/common.conf

@@ -1,6 +1,10 @@
 # lanes window — shared by macOS and Omarchy. Loaded by a SEPARATE Ghostty instance
 # (`--config-default-files=false --config-file=…`), so the everyday Ghostty config is never modified.
 # The everyday config is inherited first (fonts, theme, padding); `?` = optional include.
+# Lanes' default theme follows the desktop light/dark preference. On Omarchy the launcher keeps non-color settings
+# from the everyday config while filtering its explicit theme colors, which otherwise override this pair.
+theme = light:Catppuccin Latte,dark:Dracula
+window-theme = system
 config-file = ?~/.config/ghostty/config.ghostty
 config-file = ?~/.config/ghostty/config
 

package/payload/lanes/client/ghostty/lanes-themed-window

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Prepare the Omarchy Lanes-only Ghostty config and launch its dedicated window."""
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+
+COLORS = {
+    "theme", "window-theme", "command", "initial-command", "background", "foreground", "palette",
+    "cursor-color", "cursor-text", "selection-background", "selection-foreground",
+}
+
+
+def key_of(line):
+    text = line.strip()
+    return text.split("=", 1)[0].strip() if text and not text.startswith("#") and "=" in text else None
+
+
+def main():
+    home = Path.home()
+    config_home = Path(os.environ.get("XDG_CONFIG_HOME", home / ".config"))
+    lanes = config_home / "lanes"
+    target = lanes / "ghostty.conf"
+    base = lanes / "appearance-base.ghostty"
+    if not target.is_file():
+        raise SystemExit("Lanes Ghostty config is missing; run the Lanes installer first.")
+
+    queue = [config_home / "ghostty" / name for name in ("config.ghostty", "config")]
+    seen = set()
+    inherited = ["# Generated for Lanes from everyday Ghostty settings; theme colors are omitted."]
+    while queue:
+        path = queue.pop(0).expanduser().resolve()
+        if path in seen or not path.is_file():
+            continue
+        seen.add(path)
+        if len(seen) > 64:
+            raise SystemExit("Too many nested Ghostty config files.")
+        for line in path.read_text().splitlines():
+            key = key_of(line)
+            if key == "config-file":
+                value = line.split("=", 1)[1].strip().removeprefix("?").strip().strip('"')
+                child = Path(value).expanduser()
+                queue.append(child if child.is_absolute() else path.parent / child)
+            elif key not in COLORS:
+                inherited.append(line)
+    base.write_text("\n".join(inherited) + "\n")
+
+    lines = [line for line in target.read_text().splitlines() if key_of(line) != "config-file"]
+    lines.extend((f"config-file = {base}",))
+    appearance = lanes / "appearance.ghostty"
+    if appearance.is_file():
+        lines.append(f"config-file = {appearance}")
+    rendered = "\n".join(lines) + "\n"
+    candidate = lanes / f".ghostty-appearance.{os.getpid()}.conf"
+    candidate.write_text(rendered)
+    try:
+        ghostty = subprocess.run(["ghostty", "+validate-config", f"--config-file={candidate}"], check=False)
+        if ghostty.returncode:
+            raise SystemExit(ghostty.returncode)
+        target.write_text(rendered)
+    finally:
+        candidate.unlink(missing_ok=True)
+
+    if sys.argv[1:] == ["--prepare-only"]:
+        print(target)
+        return
+    launcher = home / ".local" / "bin" / "lanes-window"
+    os.execv(str(launcher), [str(launcher), *sys.argv[1:]])
+
+
+if __name__ == "__main__":
+    main()

package/payload/lanes/client/ghostty/omarchy.conf

@@ -1,7 +1,9 @@
 # Omarchy / Hyprland specifics for the lanes window (Ghostty GTK, dedicated instance).
-# Look & feel is inherited from ~/.config/ghostty/config (Omarchy's default: theme include, the Omarchy default font —
+# Fonts, padding and shortcuts are inherited from ~/.config/ghostty/config. The Lanes launcher filters its explicit
+# theme colors so the light/dark pair in common.conf can take effect; the everyday Ghostty config is never changed.
+# Omarchy's default font —
 # a Nerd Font is not required by lanes, every glyph is plain Unicode; shift+enter as CSI-u, control+insert /
-# shift+insert copy & paste), so Omarchy theme switches follow.
+# shift+insert copy & paste), while the Lanes palette follows the desktop light/dark preference.
 # Do NOT include the theme file here as well: Ghostty reports a second include of the same file as
 # "config-file …: cycle detected" and opens its configuration-errors window.
 

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

@@ -0,0 +1,13 @@
+{"hooks": {
+  "SessionStart": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal idle --event SessionStart --harness muse", "timeout": 2}]}],
+  "UserPromptSubmit": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event UserPromptSubmit --harness muse", "timeout": 2}]}],
+  "PreToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PreToolUse --harness muse", "timeout": 2}]}],
+  "PostToolUse": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PostToolUse --harness muse", "timeout": 2}]}],
+  "PostToolUseFailure": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal working --event PostToolUseFailure --harness muse", "timeout": 2}]}],
+  "PermissionRequest": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_approval --event PermissionRequest --harness muse", "timeout": 2}]}],
+  "Notification": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_approval --event Notification --harness muse", "timeout": 2}]}],
+  "Stop": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_input --event Stop --harness muse", "timeout": 2}]}],
+  "StopFailure": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal errored --event StopFailure --harness muse", "timeout": 2}]}],
+  "Interrupt": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal needs_input --event Interrupt --harness muse", "timeout": 2, "async": true}]}],
+  "SessionEnd": [{"hooks": [{"type": "command", "command": "~/.lz/bin/lane-signal shell --event SessionEnd --harness muse", "timeout": 2}]}]
+}}

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

@@ -0,0 +1,9 @@
+{"hooks": {
+  "SessionStart": [{"hooks": [{"type": "process", "command": "~/.lz/bin/lane-signal", "args": ["idle", "--event", "SessionStart", "--harness", "zcode"], "timeoutMs": 2000}]}],
+  "UserPromptSubmit": [{"hooks": [{"type": "process", "command": "~/.lz/bin/lane-signal", "args": ["working", "--event", "UserPromptSubmit", "--harness", "zcode"], "timeoutMs": 2000}]}],
+  "PreToolUse": [{"hooks": [{"type": "process", "command": "~/.lz/bin/lane-signal", "args": ["working", "--event", "PreToolUse", "--harness", "zcode"], "timeoutMs": 2000}]}],
+  "PostToolUse": [{"hooks": [{"type": "process", "command": "~/.lz/bin/lane-signal", "args": ["working", "--event", "PostToolUse", "--harness", "zcode"], "timeoutMs": 2000}]}],
+  "PostToolUseFailure": [{"hooks": [{"type": "process", "command": "~/.lz/bin/lane-signal", "args": ["working", "--event", "PostToolUseFailure", "--harness", "zcode"], "timeoutMs": 2000}]}],
+  "PermissionRequest": [{"hooks": [{"type": "process", "command": "~/.lz/bin/lane-signal", "args": ["needs_approval", "--event", "PermissionRequest", "--harness", "zcode"], "timeoutMs": 2000}]}],
+  "Stop": [{"hooks": [{"type": "process", "command": "~/.lz/bin/lane-signal", "args": ["needs_input", "--event", "Stop", "--harness", "zcode"], "timeoutMs": 2000}]}]
+}}

package/payload/lanes/container/lane

@@ -29,13 +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|kimi|grok|grok-cli|all] [--write]
+  lane mcp install [--agent claude|codex|kimi|grok|grok-cli|muse|zcode|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), 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`);
+                              [mcp_servers.lanes]), ~/.grok/user-settings.json (grok-cli: mcp.servers id `lanes`),
+                              ~/.config/muse/settings.json (Muse Code: mcp_servers.lanes, mode optional, env passing
+                              the lane identity) and ~/.zcode/cli/config.json (ZCode: mcp.servers.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
@@ -532,7 +534,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|kimi|grok|grok-cli|all] [--write]'
+MCP_USAGE = 'usage: lane mcp install [--agent claude|codex|kimi|grok|grok-cli|muse|zcode|all] [--write]'
 
 
 def cmd_mcp(args):
@@ -581,7 +583,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, and new Kimi Code, Grok Build and grok-cli ones where '
+        print('new Claude Code and Codex sessions load it, and new Kimi Code, Grok Build, grok-cli, Muse Code and '
+              'ZCode 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

@@ -3,7 +3,8 @@
 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, 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).
+in ~/.grok/user-settings.json (`lane mcp install`, W12), Muse Code from `mcp_servers.lanes` in ~/.config/muse/settings.json
+and ZCode from `mcp.servers.lanes` in ~/.zcode/cli/config.json (W13).
 
   usage: lane-mcp            (speaks MCP on stdin/stdout; nothing else to run by hand)
 
@@ -80,11 +81,14 @@ 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', 'GROK_SESSION_ID')   # the agent's session id, when known
+SESSION_VARS = ('CLAUDE_CODE_SESSION_ID', 'CODEX_THREAD_ID', 'GROK_SESSION_ID', 'MUSE_SESSION_ID',
+                'ZCODE_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`
+# Kimi Code's names `kimi`; W13: Muse Code `tbh` MEASURED 2026-10-16 on 1.4.10, ZCode `zcode…` INFERRED from its
+# source), else the agent process above this one (lane_core.parent_harness), else `unknown`.
+HARNESS_FILTERS = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'muse', 'zcode')   # lanes_list `agent`
+MUSE_CLIENT = 'tbh'   # Muse Code's MCP clientInfo.name (MEASURED, muse 1.4.10: {"name": "tbh", "version": "0.1.0"})
 
 
 def client_harness(client):
@@ -100,6 +104,10 @@ def client_harness(client):
         return 'grok'
     if name.startswith('grok-cli'):
         return 'grok-cli'
+    if name == MUSE_CLIENT:
+        return 'muse'
+    if name.startswith('zcode'):
+        return 'zcode'
     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 '
@@ -167,7 +175,7 @@ TOOLS = (
                                         'needs_input — the boards\' "Needs you" section).'},
            '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.'}}),
+                                    '(Grok Build) / grok-cli / muse (Muse Code) / zcode (ZCode): 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 '