@vibelord/lanes 1.5.1 → 1.6.0

package/payload/lanes/libexec/agent_state.py

@@ -49,6 +49,13 @@ then, after the turn's `agent.message.appended` dump, `agent.turn.ended{outcome:
 `interaction.request{kind: approval}` answered by `interaction.resolved` of the same id (a `question` is the other kind,
 and a cancelled turn can leave either unanswered); state.json drops `lastTurnReason` when a turn starts and sets it
 (`completed|failed|cancelled`) when one ends.
+
+W13 (spec `docs/superpowers/specs/2026-10-16-lanes-harness-observers-muse-zcode-design.md`): Muse Code and ZCode are
+observed harnesses too (HARNESS_COMMS, MUSE_COMM_PREFIX). Muse Code's own files are read by libexec/harness_muse.py
+through `muse_sessions` (its session log, joined to the pane's Muse pid by the `.session.lock` the process holds open);
+its spinner title `⠙ <workspace>` was published `codex / working` before W13, because the walk did not know Muse and
+the Codex title rule reads a spinner on an `unknown` pane (DEF-2030). ZCode keeps its sessions in SQLite and draws no
+title and no bell: it is observed by its process (`zcode` / `idle`) and its hooks only.
 """
 import importlib.util
 import json
@@ -75,8 +82,15 @@ DWELL = {'needs': 8, 'working': 5, 'done': 5, None: 0}
 GONE_DWELL = 5
 
 # W12 harness identity (spec §2). The comm (/proc/<pid>/comm, at most 15 bytes) of each harness, and what it is called.
-HARNESS_COMMS = {'claude': 'claude', 'codex': 'codex', 'kimi': 'kimi', 'kimi-code': 'kimi', 'grok': 'grok'}
-AGENT_HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli')
+# W13 (spec 2026-10-16 §2): ZCode's CLI sets process.title `zcode-cli` (its comm); Muse Code's launcher is a script named
+# `muse` that execs `muse-bin-<version>` (MEASURED 2026-10-16, muse 1.4.10: comm `muse-bin-1.4.10`, the 15-byte cut of
+# the file `muse-bin-1.4.10-R6427.1`), so Muse is also a comm that starts with MUSE_COMM_PREFIX, or an executable whose
+# file name does (MUSE_EXE_PREFIX). lane-signal's and lane_core's process_harness apply the same rule (pinned equal by
+# test_agent_state_harness.ThreeWalksAgree).
+HARNESS_COMMS = {'claude': 'claude', 'codex': 'codex', 'kimi': 'kimi', 'kimi-code': 'kimi', 'grok': 'grok',
+                 'muse': 'muse', 'zcode-cli': 'zcode'}
+MUSE_COMM_PREFIX = MUSE_EXE_PREFIX = 'muse-bin-'
+AGENT_HARNESSES = ('claude', 'codex', 'kimi', 'grok', 'grok-cli', 'muse', 'zcode')
 HARNESSES = AGENT_HARNESSES + ('shell', 'unknown')   # the published `agent.harness` enum (DM-LANES-STATUS)
 HARNESS_DEPTH = 4       # levels below the pane's root process walked for a harness
 HARNESS_FANOUT = 64     # processes examined per pane at most: a fork bomb under a pane costs a bounded read
@@ -220,15 +234,22 @@ def _named(proc_root, pid, comm):
 
 
 def _harness_of(proc_root, pid, comm):
-    """The harness process `pid` (whose comm is `comm`) is, or None: a comm in HARNESS_COMMS (`_named`), else — for a
-    process that is not a shell — native Claude Code by its executable (CLAUDE_EXE, DEF-1993). A shell's exe is its
+    """The harness process `pid` (whose comm is `comm`) is, or None: a comm in HARNESS_COMMS (`_named`), a comm that
+    starts with MUSE_COMM_PREFIX (Muse Code, W13), else — for a process that is not a shell — by its executable: native
+    Claude Code (CLAUDE_EXE, DEF-1993) or a Muse binary (a file name starting with MUSE_EXE_PREFIX). A shell's exe is its
     shell, so shells cost no readlink."""
     if comm in HARNESS_COMMS:
         return _named(proc_root, pid, comm)
     if comm is None or comm.lstrip('-') in SHELL_COMMANDS:
         return None
+    if comm.startswith(MUSE_COMM_PREFIX):
+        return 'muse'
     exe = _exe(proc_root, pid)
-    return 'claude' if exe is not None and CLAUDE_EXE in exe else None
+    if exe is None:
+        return None
+    if CLAUDE_EXE in exe:
+        return 'claude'
+    return 'muse' if exe.rpartition('/')[2].startswith(MUSE_EXE_PREFIX) else None
 
 
 def harness_walk(proc_root, pid, kids=None):
@@ -776,10 +797,60 @@ def grok_title(pane_row, bell, since):
             'pid': max(pid, 0), 'since': since, 'source': 'grok-title'}
 
 
-def merge(pane_row, claude_by_pane, sidecar, kimi_by_pane=None, grok_by_pane=None):
-    """Precedence: hook sidecar (event-driven, every harness) > Claude session file > Kimi session file > Grok observer
-    (`grok_sessions`: its session file, else the title with its blink memory) > the Grok title (`grok_title`, a pane
-    observed as `grok` nothing above claimed) > Codex title > the observed harness itself > the bell.
+def _harness_muse():
+    """libexec/harness_muse.py (W13) when it ships, else None: looked up like `_harness_grok`."""
+    module = sys.modules.get('harness_muse')
+    if module is None:
+        if importlib.util.find_spec('harness_muse') is None:
+            return None
+        import harness_muse as module
+    return module
+
+
+def muse_sessions(root, panes, *, home=CONTAINER_HOME, now=None):
+    """The Muse Code observer (W13): `harness_muse.muse_sessions(root, panes, home=home, now=now)` -> {pane key:
+    verdict}, or {} when the module does not ship. `root` the container's root as the host sees it, `panes` {pane key:
+    the pane's Muse pid} (statusd: the panes whose walk found `muse`). Kept: verdicts whose status is a vocabulary word."""
+    if not panes:
+        return {}
+    module = _harness_muse()
+    if module is None:
+        return {}
+    got = module.muse_sessions(root, panes, home=home, now=now)
+    if not isinstance(got, dict):
+        return {}
+    return {key: dict(verdict) for key, verdict in got.items()
+            if isinstance(verdict, dict) and verdict.get('status') in STATUSES}
+
+
+def muse_title(pane_row, since):
+    """merge's Muse title rung for a pane observed running Muse Code that no observer claimed:
+    `harness_muse.parse_muse_title` of its title (`⠙ <workspace>` working, any other title idle), shaped as a title
+    verdict (`source: muse-title`), or None. Muse rings no bell (MEASURED 2026-10-16), so the bell never makes it done."""
+    module = _harness_muse()
+    parse = getattr(module, 'parse_muse_title', None) if module is not None else None
+    parsed = parse(pane_row.get('pane_title')) if parse is not None else None
+    if not isinstance(parsed, dict) or parsed.get('status') not in STATUSES:
+        return None
+    try:
+        pid = int(pane_row.get('harness_pid') or 0)
+    except (TypeError, ValueError):
+        pid = 0
+    return {'harness': 'muse', 'status': parsed['status'], 'name': str(parsed.get('name') or ''), 'session_id': '',
+            'pid': max(pid, 0), 'since': since, 'source': 'muse-title'}
+
+
+# Harnesses that ring no bell (MEASURED 2026-10-16: Muse Code 1.4.10 none; ZCode has no BEL path in its source): a bell
+# flag on their pane came from something else (a tool's output), so it never turns their verdict into `done`.
+BELL_LESS = ('muse', 'zcode')
+
+
+def merge(pane_row, claude_by_pane, sidecar, kimi_by_pane=None, grok_by_pane=None, muse_by_pane=None):
+    """Precedence: hook sidecar (event-driven, every harness) > Claude session file > Kimi session file > Muse session
+    file (`muse_sessions`, W13) > Grok observer (`grok_sessions`: its session file, else the title with its blink
+    memory) > the Grok title (`grok_title`, a pane observed as `grok` nothing above claimed) > the Muse title
+    (`muse_title`, a pane observed as `muse`) > Codex title > the observed harness itself > the bell (never for a
+    BELL_LESS harness).
     Any Codex title — idle, spinner or Action Required, bell or not — over a bare-shell pane whose shell has no
     child process (`pane_has_child is False`, statusd's row key) publishes `shell`: the harness ended and tmux kept
     its last title, so no ghost idle/done/working/needs_approval. Unknown liveness leaves the title in charge.
@@ -794,22 +865,23 @@ def merge(pane_row, claude_by_pane, sidecar, kimi_by_pane=None, grok_by_pane=Non
     nothing above claimed is that harness, `idle`, `done` with the bell (`source: process`, `pid` the harness pid statusd
     found). Returns None when nothing says an agent is here — the sidebar then draws a plain shell."""
     observed = pane_row.get('harness')
-    verdict = _verdict(pane_row, claude_by_pane, sidecar, kimi_by_pane or {}, grok_by_pane or {}, observed)
+    verdict = _verdict(pane_row, claude_by_pane, sidecar, kimi_by_pane or {}, grok_by_pane or {}, muse_by_pane or {},
+                       observed)
     if verdict is not None and observed in AGENT_HARNESSES:
         verdict['harness'] = observed
     return verdict
 
 
-def _verdict(pane_row, claude_by_pane, sidecar, kimi_by_pane, grok_by_pane, observed):
+def _verdict(pane_row, claude_by_pane, sidecar, kimi_by_pane, grok_by_pane, muse_by_pane, observed):
     if sidecar and sidecar.get('status') in STATUSES:
         return dict(sidecar, source=sidecar.get('source') or 'hook')
     key = pane_key(pane_row)
     if key in claude_by_pane:
         return dict(claude_by_pane[key])
-    bell = pane_row.get('window_bell_flag') == '1'
+    bell = pane_row.get('window_bell_flag') == '1' and observed not in BELL_LESS
     # The Kimi observer leaves the bell to merge; the Grok observer applies it itself (harness_grok: only a completed
-    # turn or an idle title is `done` — a cancelled or interrupted turn stays needs_input, spec §4).
-    for index, rings in ((kimi_by_pane, True), (grok_by_pane, False)):
+    # turn or an idle title is `done` — a cancelled or interrupted turn stays needs_input, spec §4); Muse rings none.
+    for index, rings in ((kimi_by_pane, True), (muse_by_pane, False), (grok_by_pane, False)):
         found = index.get(key)
         if isinstance(found, dict) and found.get('status') == GROK_UNKNOWN:
             return None   # seen, not joinable (Grok's leader mode): no guess below
@@ -826,6 +898,10 @@ def _verdict(pane_row, claude_by_pane, sidecar, kimi_by_pane, grok_by_pane, obse
         found = grok_title(pane_row, bell, activity)
         if found:
             return found
+    if observed == 'muse':
+        found = muse_title(pane_row, activity)
+        if found:
+            return found
     title = parse_codex_title(pane_row.get('pane_title'), observed)
     if title:
         if _harness_ended(pane_row):