muuuuse 1.3.2 → 1.4.1

package/src/runtime.js

@@ -1,10 +1,9 @@
 const fs = require("node:fs");
-const path = require("node:path");
+const { execFileSync } = require("node:child_process");
 const pty = require("node-pty");
 
 const {
-  detectAgentTypeFromCommand,
-  expandPresetCommand,
+  detectAgent,
   readClaudeAnswers,
   readCodexAnswers,
   readGeminiAnswers,
@@ -17,189 +16,201 @@ const {
   POLL_MS,
   appendJsonl,
   createId,
+  ensureDir,
   getDefaultSessionName,
   getFileSize,
   getSeatPaths,
-  getStateRoot,
+  getSessionPaths,
   hashText,
   isPidAlive,
+  listSessionNames,
   readAppendedText,
   readJson,
-  resetDir,
   sanitizeRelayText,
   sleep,
   writeJson,
 } = require("./util");
 
-const GENERIC_IDLE_MS = 900;
+const TYPE_DELAY_MS = 70;
+const MIRROR_SUPPRESSION_WINDOW_MS = 30 * 1000;
+const MAX_RECENT_INBOUND_RELAYS = 12;
+const STOP_FORCE_KILL_MS = 1200;
 
-function resolveSessionName(sessionOverride, currentPath = process.cwd()) {
-  return sessionOverride || getDefaultSessionName(currentPath);
+function resolveShell() {
+  const shell = String(process.env.SHELL || "").trim();
+  return shell || "/bin/bash";
 }
 
-function resolveProgramTokens(commandTokens, usePresets = true) {
-  const resolved = expandPresetCommand(commandTokens, usePresets);
-  if (resolved.length === 0) {
-    throw new Error("Seat commands now require a program. Example: `muuuuse 1 codex`.");
+function resolveShellArgs(shellPath) {
+  const base = shellPath.split("/").pop();
+  if (base === "bash" || base === "zsh" || base === "fish") {
+    return ["-i"];
   }
-  return resolved;
+  return [];
 }
 
-function formatCommand(commandTokens) {
-  return commandTokens
-    .map((token) => {
-      if (/^[a-zA-Z0-9._/@:=+-]+$/.test(token)) {
-        return token;
-      }
-      return JSON.stringify(token);
-    })
-    .join(" ");
+function resolveChildTerm() {
+  const inherited = String(process.env.TERM || "").trim();
+  if (inherited && inherited.toLowerCase() !== "dumb") {
+    return inherited;
+  }
+  return "xterm-256color";
 }
 
-function previewText(text, maxLength = 88) {
-  const compact = sanitizeRelayText(text).replace(/\s+/g, " ");
-  if (compact.length <= maxLength) {
-    return compact;
-  }
-  return `${compact.slice(0, maxLength - 3)}...`;
+function resolveSessionName(currentPath = process.cwd()) {
+  return getDefaultSessionName(currentPath);
 }
 
 function parseAnswerEntries(text) {
   return String(text || "")
     .split("\n")
     .map((line) => line.trim())
-    .filter((line) => line.length > 0)
+    .filter(Boolean)
     .map((line) => {
       try {
         return JSON.parse(line);
-      } catch (error) {
+      } catch {
         return null;
       }
     })
     .filter((entry) => entry && entry.type === "answer" && typeof entry.text === "string");
 }
 
-function resolveSessionFile(agentType, currentPath, processStartedAtMs, options = {}) {
-  if (agentType === "codex") {
-    return selectCodexSessionFile(currentPath, processStartedAtMs, options);
-  }
-  if (agentType === "claude") {
-    return selectClaudeSessionFile(currentPath, processStartedAtMs);
+function readProcessCwd(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return null;
   }
-  if (agentType === "gemini") {
-    return selectGeminiSessionFile(currentPath, processStartedAtMs);
+
+  try {
+    return fs.realpathSync(`/proc/${pid}/cwd`);
+  } catch {
+    return null;
   }
-  return null;
 }
 
-class GenericAnswerTracker {
-  constructor() {
-    this.active = false;
-    this.buffer = "";
-    this.lastInputText = "";
-    this.lastOutputAt = 0;
-    this.lastFingerprint = null;
+function getChildProcesses(rootPid) {
+  if (!Number.isInteger(rootPid) || rootPid <= 0) {
+    return [];
   }
 
-  noteTurnStart(inputText = "") {
-    this.active = true;
-    this.buffer = "";
-    this.lastInputText = sanitizeRelayText(inputText);
-    this.lastOutputAt = 0;
-  }
+  try {
+    const output = execFileSync("ps", ["-axo", "pid=,ppid=,etimes=,command="], {
+      encoding: "utf8",
+    });
 
-  append(data) {
-    if (!this.active) {
-      return;
+    const processes = output
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0)
+      .map((line) => {
+        const match = line.match(/^(\d+)\s+(\d+)\s+(\d+)\s+(.*)$/);
+        if (!match) {
+          return null;
+        }
+
+        return {
+          pid: Number.parseInt(match[1], 10),
+          ppid: Number.parseInt(match[2], 10),
+          elapsedSeconds: Number.parseInt(match[3], 10),
+          args: match[4],
+        };
+      })
+      .filter((entry) => entry !== null);
+
+    const descendants = [];
+    const queue = [rootPid];
+    const seen = new Set(queue);
+
+    while (queue.length > 0) {
+      const parentPid = queue.shift();
+      for (const process of processes) {
+        if (process.ppid !== parentPid || seen.has(process.pid)) {
+          continue;
+        }
+        seen.add(process.pid);
+        queue.push(process.pid);
+        descendants.push({
+          ...process,
+          cwd: readProcessCwd(process.pid),
+        });
+      }
     }
 
-    this.buffer += String(data || "");
-    this.lastOutputAt = Date.now();
+    return descendants.sort((left, right) => left.elapsedSeconds - right.elapsedSeconds);
+  } catch {
+    return [];
+  }
+}
 
-    if (this.buffer.length > 24000) {
-      this.buffer = this.buffer.slice(-24000);
-    }
+function resolveSessionFile(agentType, currentPath, processStartedAtMs) {
+  if (!currentPath) {
+    return null;
   }
 
-  consumeReady() {
-    if (!this.active || !this.lastOutputAt) {
-      return null;
-    }
+  if (agentType === "codex") {
+    return selectCodexSessionFile(currentPath, processStartedAtMs);
+  }
+  if (agentType === "claude") {
+    return selectClaudeSessionFile(currentPath, processStartedAtMs);
+  }
+  if (agentType === "gemini") {
+    return selectGeminiSessionFile(currentPath, processStartedAtMs);
+  }
+  return null;
+}
 
-    if (Date.now() - this.lastOutputAt < GENERIC_IDLE_MS) {
-      return null;
-    }
+async function sendTextAndEnter(child, text, shouldAbort = () => false) {
+  const lines = String(text || "").replace(/\r/g, "").split("\n");
 
-    const text = extractGenericAnswer(this.buffer, this.lastInputText);
-    if (!text) {
-      return null;
+  for (let index = 0; index < lines.length; index += 1) {
+    if (shouldAbort() || !child) {
+      return false;
     }
 
-    const fingerprint = hashText(`${this.lastInputText}\n${text}`);
-    if (fingerprint === this.lastFingerprint) {
-      return null;
+    const line = lines[index];
+    if (line.length > 0) {
+      try {
+        child.write(line);
+      } catch {
+        return false;
+      }
+      await sleep(TYPE_DELAY_MS);
     }
 
-    this.lastFingerprint = fingerprint;
-    this.active = false;
-    return text;
-  }
-}
-
-function extractGenericAnswer(rawText, lastInputText) {
-  let candidate = sanitizeRelayText(rawText, 12000);
-  if (!candidate) {
-    return null;
-  }
+    if (index < lines.length - 1) {
+      if (shouldAbort()) {
+        return false;
+      }
 
-  if (lastInputText) {
-    if (candidate === lastInputText) {
-      return null;
-    }
-    if (candidate.startsWith(`${lastInputText}\n`)) {
-      candidate = candidate.slice(lastInputText.length).trim();
+      try {
+        child.write("\r");
+      } catch {
+        return false;
+      }
+      await sleep(TYPE_DELAY_MS);
     }
   }
 
-  const markerAnswer = extractMarkedAnswer(candidate);
-  if (markerAnswer) {
-    return markerAnswer;
+  if (shouldAbort() || !child) {
+    return false;
   }
 
-  const blocks = candidate
-    .split(/\n{2,}/)
-    .map((block) => block.trim())
-    .filter((block) => block.length > 0);
-
-  if (blocks.length === 0) {
-    return null;
-  }
-
-  return sanitizeRelayText(blocks[blocks.length - 1]);
-}
-
-function extractMarkedAnswer(content) {
-  const lines = String(content || "").split("\n");
-  const answerIndex = lines.findIndex((line) => line.trim().startsWith("(answer)"));
-  if (answerIndex === -1) {
-    return null;
+  try {
+    child.write("\r");
+  } catch {
+    return false;
   }
 
-  const answerLines = lines.slice(answerIndex);
-  answerLines[0] = answerLines[0].trim().replace(/^\(answer\)\s*/, "");
-  return sanitizeRelayText(answerLines.join("\n"));
+  return true;
 }
 
-class SeatProcess {
+class ArmedSeat {
   constructor(options) {
     this.seatId = options.seatId;
     this.partnerSeatId = options.seatId === 1 ? 2 : 1;
-    this.sessionName = options.sessionName;
     this.cwd = options.cwd;
-    this.commandTokens = [...options.commandTokens];
-    this.agentType = detectAgentTypeFromCommand(this.commandTokens);
-    this.maxRelays = options.maxRelays;
-
+    this.sessionName = resolveSessionName(this.cwd);
+    this.sessionPaths = getSessionPaths(this.sessionName);
     this.paths = getSeatPaths(this.sessionName, this.seatId);
     this.partnerPaths = getSeatPaths(this.sessionName, this.partnerSeatId);
     this.partnerOffset = getFileSize(this.partnerPaths.eventsPath);
@@ -207,22 +218,26 @@ class SeatProcess {
     this.child = null;
     this.childPid = null;
     this.childExit = null;
+    this.startedAt = new Date().toISOString();
     this.startedAtMs = Date.now();
     this.relayCount = 0;
-    this.linked = false;
     this.stopped = false;
+    this.stopReason = null;
     this.stdinCleanup = null;
     this.resizeCleanup = null;
-    this.childToken = createId(16);
-    this.processStartedAtMs = null;
-
-    this.sessionState = {
-      file: null,
+    this.forceKillTimer = null;
+    this.recentInboundRelays = [];
+    this.liveState = {
+      type: null,
+      pid: null,
+      currentPath: null,
+      sessionFile: null,
       offset: 0,
       lastMessageId: null,
+      processStartedAtMs: null,
+      captureSinceMs: this.startedAtMs,
+      lastAnswerAt: null,
     };
-
-    this.genericTracker = new GenericAnswerTracker();
   }
 
   log(message) {
@@ -232,15 +247,13 @@ class SeatProcess {
   writeMeta(extra = {}) {
     writeJson(this.paths.metaPath, {
       seatId: this.seatId,
+      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       cwd: this.cwd,
       pid: process.pid,
       childPid: this.childPid,
-      childToken: this.childToken,
-      agentType: this.agentType,
-      command: this.commandTokens,
-      commandLine: formatCommand(this.commandTokens),
-      startedAt: new Date(this.startedAtMs).toISOString(),
+      command: [resolveShell(), ...resolveShellArgs(resolveShell())],
+      startedAt: this.startedAt,
       ...extra,
     });
   }
@@ -248,26 +261,52 @@ class SeatProcess {
   writeStatus(extra = {}) {
     writeJson(this.paths.statusPath, {
       seatId: this.seatId,
+      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       cwd: this.cwd,
       pid: process.pid,
       childPid: this.childPid,
-      childToken: this.childToken,
-      agentType: this.agentType,
-      command: this.commandTokens,
       relayCount: this.relayCount,
       updatedAt: new Date().toISOString(),
       ...extra,
     });
   }
 
-  installSignalHandlers() {
-    const stop = () => {
+  launchShell() {
+    ensureDir(this.paths.dir);
+    fs.rmSync(this.paths.pipePath, { force: true });
+    clearStaleStopRequest(this.sessionPaths.stopPath, this.startedAtMs);
+
+    const shell = resolveShell();
+    const shellArgs = resolveShellArgs(shell);
+    this.child = pty.spawn(shell, shellArgs, {
+      cols: process.stdout.columns || 120,
+      rows: process.stdout.rows || 36,
+      cwd: this.cwd,
+      env: {
+        ...process.env,
+        TERM: resolveChildTerm(),
+        MUUUUSE_SEAT: String(this.seatId),
+        MUUUUSE_SESSION: this.sessionName,
+      },
+      name: resolveChildTerm(),
+    });
+
+    this.childPid = this.child.pid;
+    this.writeMeta();
+    this.writeStatus({ state: "running" });
+
+    this.child.onData((data) => {
+      fs.appendFileSync(this.paths.pipePath, data);
+      if (!this.stopped) {
+        process.stdout.write(data);
+      }
+    });
+
+    this.child.onExit(({ exitCode, signal }) => {
+      this.childExit = { exitCode, signal: signal || null };
       this.stopped = true;
-    };
-    process.once("SIGINT", stop);
-    process.once("SIGHUP", stop);
-    process.once("SIGTERM", stop);
+    });
   }
 
   installStdinProxy() {
@@ -275,13 +314,9 @@ class SeatProcess {
       if (!this.child) {
         return;
       }
-
-      const text = chunk.toString("utf8");
-      this.child.write(text);
-      if (this.shouldUseGenericCapture() && /[\r\n]/.test(text)) {
-        this.genericTracker.noteTurnStart("");
-      }
+      this.child.write(chunk.toString("utf8"));
     };
+
     const handleEnd = () => {
       this.stopped = true;
     };
@@ -315,9 +350,9 @@ class SeatProcess {
       }
 
       try {
-        this.child.resize(process.stdout.columns || 80, process.stdout.rows || 24);
-      } catch (error) {
-        // Ignore resize failures while the child is exiting.
+        this.child.resize(process.stdout.columns || 120, process.stdout.rows || 36);
+      } catch {
+        // Ignore resize races while the child is exiting.
       }
     };
 
@@ -327,80 +362,91 @@ class SeatProcess {
     };
   }
 
-  launchChild() {
-    resetDir(this.paths.dir);
+  installStopSignals() {
+    const requestStop = () => {
+      this.requestStop("signal");
+    };
 
-    const [file, ...args] = this.commandTokens;
-    this.child = pty.spawn(file, args, {
-      cols: process.stdout.columns || 80,
-      cwd: this.cwd,
-      env: {
-        ...process.env,
-        MUUUUSE_CHILD_TOKEN: this.childToken,
-        MUUUUSE_SEAT: String(this.seatId),
-        MUUUUSE_SESSION: this.sessionName,
-      },
-      name: process.env.TERM || "xterm-256color",
-      rows: process.stdout.rows || 24,
-    });
+    process.on("SIGTERM", requestStop);
+    process.on("SIGHUP", requestStop);
+  }
 
-    this.childPid = this.child.pid;
-    this.processStartedAtMs = Date.now();
-    this.writeMeta();
-    this.writeStatus({
-      partnerSeatId: this.partnerSeatId,
-      state: "running",
-    });
+  requestStop(reason = "stop_requested") {
+    if (this.stopped) {
+      return;
+    }
 
-    this.child.onData((data) => {
-      process.stdout.write(data);
-      if (this.shouldUseGenericCapture()) {
-        this.genericTracker.append(data);
-      }
-    });
+    this.stopped = true;
+    this.stopReason = reason;
 
-    this.child.onExit(({ exitCode, signal }) => {
-      this.childExit = {
-        exitCode,
-        signal: signal || null,
-      };
-      this.stopped = true;
-    });
-  }
+    if (this.childPid) {
+      signalProcessFamily(this.childPid, "SIGHUP");
+      signalProcessFamily(this.childPid, "SIGTERM");
+      this.scheduleForcedKill();
+    }
 
-  partnerIsLive() {
-    const partnerStatus = readJson(this.partnerPaths.statusPath, null);
-    return Boolean(partnerStatus?.pid && isPidAlive(partnerStatus.pid));
+    if (this.child && !this.childExit) {
+      try {
+        this.child.kill();
+      } catch {
+        // best effort shutdown
+      }
+    }
   }
 
-  maybeMarkLinked() {
-    if (this.linked || !this.partnerIsLive()) {
+  scheduleForcedKill() {
+    if (this.forceKillTimer || !this.childPid) {
       return;
     }
 
-    this.linked = true;
-    this.log(`${BRAND} seat ${this.seatId} linked with seat ${this.partnerSeatId} in session ${this.sessionName}.`);
+    this.forceKillTimer = setTimeout(() => {
+      this.forceKillTimer = null;
+      if (!this.childPid || this.childExit) {
+        return;
+      }
+
+      signalProcessFamily(this.childPid, "SIGKILL");
+      if (this.child && !this.childExit) {
+        try {
+          this.child.kill();
+        } catch {
+          // best effort hard shutdown
+        }
+      }
+    }, STOP_FORCE_KILL_MS);
+
+    if (typeof this.forceKillTimer.unref === "function") {
+      this.forceKillTimer.unref();
+    }
+  }
+
+  partnerIsLive() {
+    const partner = readJson(this.partnerPaths.statusPath, null);
+    return Boolean(partner?.pid && isPidAlive(partner.pid));
   }
 
-  shouldUseGenericCapture() {
-    return !this.agentType;
+  stopRequested() {
+    const request = readJson(this.sessionPaths.stopPath, null);
+    if (!request?.requestedAt) {
+      return false;
+    }
+
+    const requestedAtMs = Date.parse(request.requestedAt);
+    return Number.isFinite(requestedAtMs) && requestedAtMs > this.startedAtMs;
   }
 
-  pullPartnerEvents() {
+  async pullPartnerEvents() {
     const { nextOffset, text } = readAppendedText(this.partnerPaths.eventsPath, this.partnerOffset);
     this.partnerOffset = nextOffset;
-    if (!text.trim()) {
+    if (!text.trim() || !this.child || this.stopped) {
       return;
     }
 
     const entries = parseAnswerEntries(text);
     for (const entry of entries) {
-      if (!this.child) {
-        continue;
-      }
-      if (Number.isFinite(this.maxRelays) && this.relayCount >= this.maxRelays) {
-        this.log(`${BRAND} seat ${this.seatId} hit the relay cap (${this.maxRelays}).`);
-        continue;
+      if (this.stopped || this.stopRequested()) {
+        this.requestStop("stop_requested");
+        return;
       }
 
       const payload = sanitizeRelayText(entry.text);
@@ -408,98 +454,199 @@ class SeatProcess {
         continue;
       }
 
-      if (this.shouldUseGenericCapture()) {
-        this.genericTracker.noteTurnStart(payload);
+      const delivered = await sendTextAndEnter(
+        this.child,
+        payload,
+        () => this.stopped || this.stopRequested() || !this.child || Boolean(this.childExit)
+      );
+      if (!delivered) {
+        this.requestStop("relay_aborted");
+        return;
+      }
+
+      if (this.stopped || this.stopRequested()) {
+        this.requestStop("stop_requested");
+        return;
       }
 
-      this.child.write(payload.replace(/\n/g, "\r"));
-      this.child.write("\r");
       this.relayCount += 1;
+      this.rememberInboundRelay(payload);
       this.log(`[${this.partnerSeatId} -> ${this.seatId}] ${previewText(payload)}`);
     }
   }
 
-  resolveStructuredLog() {
-    if (!this.agentType || this.sessionState.file) {
+  rememberInboundRelay(text) {
+    const payload = sanitizeRelayText(text);
+    if (!payload) {
       return;
     }
 
-    const sessionFile = resolveSessionFile(this.agentType, this.cwd, this.processStartedAtMs, {
-      snapshotEnv: this.agentType === "codex"
-        ? {
-          MUUUUSE_CHILD_TOKEN: this.childToken,
-          MUUUUSE_SEAT: String(this.seatId),
-          MUUUUSE_SESSION: this.sessionName,
-        }
-        : null,
+    const now = Date.now();
+    this.pruneRecentInboundRelays(now);
+    this.recentInboundRelays.push({
+      hash: hashText(payload),
+      text: payload,
+      timestampMs: now,
     });
-    if (!sessionFile) {
-      return;
-    }
 
-    this.sessionState.file = sessionFile;
-    if (this.agentType === "gemini") {
-      const baseline = readGeminiAnswers(sessionFile, null);
-      this.sessionState.lastMessageId = baseline.lastMessageId;
-      this.sessionState.offset = baseline.fileSize;
-    } else {
-      this.sessionState.offset = getFileSize(sessionFile);
+    if (this.recentInboundRelays.length > MAX_RECENT_INBOUND_RELAYS) {
+      this.recentInboundRelays = this.recentInboundRelays.slice(-MAX_RECENT_INBOUND_RELAYS);
     }
   }
 
-  collectStructuredAnswers() {
-    this.resolveStructuredLog();
-    if (!this.sessionState.file || !this.agentType) {
-      return;
+  pruneRecentInboundRelays(now = Date.now()) {
+    this.recentInboundRelays = this.recentInboundRelays.filter(
+      (entry) => now - entry.timestampMs <= MIRROR_SUPPRESSION_WINDOW_MS
+    );
+  }
+
+  takeMirroredInboundRelay(payload) {
+    const normalized = sanitizeRelayText(payload);
+    if (!normalized) {
+      return null;
+    }
+
+    this.pruneRecentInboundRelays();
+    const payloadHash = hashText(normalized);
+    const matchIndex = this.recentInboundRelays.findIndex((entry) => entry.hash === payloadHash);
+    if (matchIndex === -1) {
+      return null;
+    }
+
+    const [match] = this.recentInboundRelays.splice(matchIndex, 1);
+    return match;
+  }
+
+  collectLiveAnswers() {
+    const detectedAgent = detectAgent(getChildProcesses(this.childPid));
+    if (!detectedAgent) {
+      this.liveState = {
+        type: null,
+        pid: null,
+        currentPath: null,
+        sessionFile: null,
+        offset: 0,
+        lastMessageId: null,
+        processStartedAtMs: null,
+        captureSinceMs: this.startedAtMs,
+        lastAnswerAt: null,
+      };
+
+      return {
+        state: this.childExit ? "exited" : "running",
+        agent: null,
+        cwd: this.cwd,
+        log: null,
+        lastAnswerAt: null,
+      };
+    }
+
+    const currentPath = detectedAgent.cwd || this.cwd;
+    const changed =
+      this.liveState.type !== detectedAgent.type ||
+      this.liveState.pid !== detectedAgent.pid ||
+      this.liveState.currentPath !== currentPath;
+
+    if (changed) {
+      this.liveState = {
+        type: detectedAgent.type,
+        pid: detectedAgent.pid,
+        currentPath,
+        sessionFile: null,
+        offset: 0,
+        lastMessageId: null,
+        processStartedAtMs: detectedAgent.processStartedAtMs,
+        captureSinceMs: Math.max(
+          this.startedAtMs,
+          Number.isFinite(detectedAgent.processStartedAtMs) ? detectedAgent.processStartedAtMs : 0
+        ),
+        lastAnswerAt: null,
+      };
+    }
+
+    if (!this.liveState.sessionFile) {
+      this.liveState.sessionFile = resolveSessionFile(
+        detectedAgent.type,
+        currentPath,
+        detectedAgent.processStartedAtMs
+      );
+
+      if (this.liveState.sessionFile) {
+        this.liveState.offset = 0;
+        this.liveState.lastMessageId = null;
+      }
+    }
+
+    if (!this.liveState.sessionFile) {
+      return {
+        state: "running",
+        agent: detectedAgent.type,
+        cwd: currentPath,
+        log: "waiting_for_session_log",
+        lastAnswerAt: this.liveState.lastAnswerAt,
+      };
     }
 
     const answers = [];
-    if (this.agentType === "codex") {
-      const result = readCodexAnswers(this.sessionState.file, this.sessionState.offset);
-      this.sessionState.offset = result.nextOffset;
+    if (detectedAgent.type === "codex") {
+      const result = readCodexAnswers(
+        this.liveState.sessionFile,
+        this.liveState.offset,
+        this.liveState.captureSinceMs
+      );
+      this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
-    } else if (this.agentType === "claude") {
-      const result = readClaudeAnswers(this.sessionState.file, this.sessionState.offset);
-      this.sessionState.offset = result.nextOffset;
+    } else if (detectedAgent.type === "claude") {
+      const result = readClaudeAnswers(
+        this.liveState.sessionFile,
+        this.liveState.offset,
+        this.liveState.captureSinceMs
+      );
+      this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
-    } else if (this.agentType === "gemini") {
-      const result = readGeminiAnswers(this.sessionState.file, this.sessionState.lastMessageId);
-      this.sessionState.lastMessageId = result.lastMessageId;
-      this.sessionState.offset = result.fileSize;
+    } else if (detectedAgent.type === "gemini") {
+      const result = readGeminiAnswers(
+        this.liveState.sessionFile,
+        this.liveState.lastMessageId,
+        this.liveState.captureSinceMs
+      );
+      this.liveState.lastMessageId = result.lastMessageId;
+      this.liveState.offset = result.fileSize;
       answers.push(...result.answers);
     }
 
     for (const answer of answers) {
       this.emitAnswer({
-        createdAt: answer.timestamp,
-        id: answer.id,
-        origin: this.agentType,
+        id: answer.id || createId(12),
+        origin: detectedAgent.type,
         text: answer.text,
+        createdAt: answer.timestamp || new Date().toISOString(),
       });
+      this.liveState.lastAnswerAt = answer.timestamp || new Date().toISOString();
     }
+
+    return {
+      state: "running",
+      agent: detectedAgent.type,
+      cwd: currentPath,
+      log: this.liveState.sessionFile,
+      lastAnswerAt: this.liveState.lastAnswerAt,
+    };
   }
 
-  collectGenericAnswers() {
-    if (!this.shouldUseGenericCapture()) {
+  emitAnswer(entry) {
+    if (this.stopped) {
       return;
     }
 
-    const text = this.genericTracker.consumeReady();
-    if (!text) {
+    const payload = sanitizeRelayText(entry.text);
+    if (!payload) {
       return;
     }
 
-    this.emitAnswer({
-      createdAt: new Date().toISOString(),
-      id: createId(12),
-      origin: "generic",
-      text,
-    });
-  }
-
-  emitAnswer(entry) {
-    const text = sanitizeRelayText(entry.text);
-    if (!text) {
+    const mirroredInbound = this.takeMirroredInboundRelay(payload);
+    if (mirroredInbound) {
+      this.log(`[${this.seatId}] suppressed mirrored relay: ${previewText(payload)}`);
       return;
     }
 
@@ -508,36 +655,53 @@ class SeatProcess {
       type: "answer",
       seatId: this.seatId,
       origin: entry.origin || "unknown",
-      text,
+      text: payload,
       createdAt: entry.createdAt || new Date().toISOString(),
     });
 
-    this.log(`[${this.seatId}] ${previewText(text)}`);
+    this.log(`[${this.seatId}] ${previewText(payload)}`);
   }
 
   async tick() {
-    this.maybeMarkLinked();
-    this.pullPartnerEvents();
-    this.collectStructuredAnswers();
-    this.collectGenericAnswers();
+    if (this.stopRequested()) {
+      this.writeStatus({
+        state: "stopping",
+        partnerLive: this.partnerIsLive(),
+      });
+      this.requestStop("stop_requested");
+      return;
+    }
+
+    await this.pullPartnerEvents();
+    if (this.stopped || this.stopRequested()) {
+      this.requestStop("stop_requested");
+      return;
+    }
+
+    const live = this.collectLiveAnswers();
+    if (this.stopped) {
+      return;
+    }
 
     this.writeStatus({
-      partnerSeatId: this.partnerSeatId,
+      state: live.state,
+      agent: live.agent,
+      cwd: live.cwd,
+      log: live.log,
+      lastAnswerAt: live.lastAnswerAt,
       partnerLive: this.partnerIsLive(),
-      state: this.childExit ? "exited" : "running",
-      structuredLog: this.sessionState.file,
     });
   }
 
   async run() {
-    this.installSignalHandlers();
-    this.launchChild();
+    this.installStopSignals();
+    this.launchShell();
     this.installStdinProxy();
     this.installResizeHandler();
 
-    this.log(`${BRAND} seat ${this.seatId} started in session ${this.sessionName}.`);
-    this.log(`Command: ${formatCommand(this.commandTokens)}`);
-    this.log(`Stop everything from another terminal with: muuuuse stop`);
+    this.log(`${BRAND} seat ${this.seatId} armed for ${this.sessionName}.`);
+    this.log("Use this shell normally. Codex, Claude, and Gemini final answers relay automatically from their local session logs.");
+    this.log("Run `muuuuse status` or `muuuuse stop` from any terminal.");
 
     try {
       while (!this.stopped) {
@@ -552,6 +716,11 @@ class SeatProcess {
   }
 
   cleanup() {
+    if (this.forceKillTimer) {
+      clearTimeout(this.forceKillTimer);
+      this.forceKillTimer = null;
+    }
+
     if (this.stdinCleanup) {
       this.stdinCleanup();
       this.stdinCleanup = null;
@@ -563,9 +732,9 @@ class SeatProcess {
 
     if (this.child && !this.childExit) {
       try {
-        this.child.kill("SIGTERM");
-      } catch (error) {
-        // Ignore races during shutdown.
+        this.child.kill();
+      } catch {
+        // best effort
       }
     }
 
@@ -575,135 +744,218 @@ class SeatProcess {
     });
     this.writeStatus({
       childPid: this.childPid,
-      exitCode: this.childExit?.exitCode ?? null,
       exitedAt: new Date().toISOString(),
-      partnerSeatId: this.partnerSeatId,
       state: "exited",
     });
   }
 }
 
-function stopSession(sessionName) {
-  const results = [];
+function previewText(text, maxLength = 88) {
+  const compact = sanitizeRelayText(text).replace(/\s+/g, " ");
+  if (compact.length <= maxLength) {
+    return compact;
+  }
+  return `${compact.slice(0, maxLength - 3)}...`;
+}
 
-  for (const seatId of [1, 2]) {
-    const paths = getSeatPaths(sessionName, seatId);
-    const status = readJson(paths.statusPath, null);
-    const meta = readJson(paths.metaPath, null);
-    const wrapperPid = status?.pid || meta?.pid || null;
-    const childPid = status?.childPid || meta?.childPid || null;
+function buildSeatReport(sessionName, seatId) {
+  const paths = getSeatPaths(sessionName, seatId);
+  const daemon = readJson(paths.daemonPath, null);
+  const status = readJson(paths.statusPath, null);
+  const meta = readJson(paths.metaPath, null);
 
-    let wrapperStopped = false;
-    let childStopped = false;
+  if (!status && !meta && !daemon) {
+    return null;
+  }
 
-    if (wrapperPid && isPidAlive(wrapperPid)) {
-      try {
-        process.kill(wrapperPid, "SIGTERM");
-        wrapperStopped = true;
-      } catch (error) {
-        wrapperStopped = false;
-      }
-    }
+  const legacyTmux = Boolean(daemon?.pid || meta?.paneId);
+  const wrapperPid = status?.pid || daemon?.pid || meta?.pid || null;
+  const childPid = status?.childPid || meta?.childPid || null;
+  const wrapperLive = isPidAlive(wrapperPid);
+  const childLive = isPidAlive(childPid);
 
-    if (childPid && isPidAlive(childPid)) {
-      try {
-        process.kill(childPid, "SIGTERM");
-        childStopped = true;
-      } catch (error) {
-        childStopped = false;
-      }
-    }
-
-    results.push({
-      seatId,
-      childPid,
-      childStopped,
-      wrapperPid,
-      wrapperStopped,
-    });
+  if (!wrapperLive && !childLive) {
+    return null;
   }
 
   return {
-    sessionName,
-    seats: results,
+    seatId,
+    state: wrapperLive ? status?.state || "running" : "orphaned_child",
+    wrapperPid,
+    childPid,
+    wrapperLive,
+    childLive,
+    legacyTmux,
+    agent: status?.agent || null,
+    cwd: status?.cwd || meta?.cwd || null,
+    relayCount: status?.relayCount || 0,
+    log: status?.log || null,
+    startedAt: meta?.startedAt || null,
+    updatedAt: status?.updatedAt || null,
+    lastAnswerAt: status?.lastAnswerAt || null,
+    partnerLive: Boolean(status?.partnerLive),
   };
 }
 
-function listSessionNames() {
-  const sessionsRoot = path.join(getStateRoot(), "sessions");
-  try {
-    return fs.readdirSync(sessionsRoot, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-      .sort();
-  } catch (error) {
-    return [];
-  }
+function getStatusReport() {
+  const sessions = listSessionNames()
+    .map((sessionName) => {
+      const sessionPaths = getSessionPaths(sessionName);
+      const controller = readJson(sessionPaths.controllerPath, null);
+      const stopRequest = readJson(sessionPaths.stopPath, null);
+      const seats = [1, 2]
+        .map((seatId) => buildSeatReport(sessionName, seatId))
+        .filter((entry) => entry !== null);
+
+      const controllerPid = controller?.pid || null;
+      const controllerLive = isPidAlive(controllerPid);
+
+      if (seats.length === 0 && !controllerLive) {
+        return null;
+      }
+
+      const stopRequestedAt = selectVisibleStopRequest(stopRequest?.requestedAt, seats);
+
+      return {
+        sessionName,
+        controllerPid,
+        controllerLive,
+        stopRequestedAt,
+        seats,
+      };
+    })
+    .filter((entry) => entry !== null);
+
+  return { sessions };
 }
 
-async function stopSessions(sessionName = null) {
-  const sessionNames = sessionName ? [sessionName] : listSessionNames();
-  const sessionResults = sessionNames.map((name) => stopSession(name));
+function stopAllSessions() {
+  const report = getStatusReport();
+  const requestedAt = new Date().toISOString();
 
-  await sleep(200);
+  for (const session of report.sessions) {
+    const sessionPaths = getSessionPaths(session.sessionName);
+    writeJson(sessionPaths.stopPath, {
+      requestId: createId(12),
+      requestedAt,
+    });
 
-  for (const sessionResult of sessionResults) {
-    for (const seat of sessionResult.seats) {
-      if (seat.wrapperPid && isPidAlive(seat.wrapperPid)) {
-        try {
-          process.kill(seat.wrapperPid, "SIGKILL");
-          seat.wrapperForced = true;
-        } catch (error) {
-          seat.wrapperForced = false;
+    if (session.controllerLive) {
+      signalPid(session.controllerPid, "SIGTERM");
+    }
+
+    for (const seat of session.seats) {
+      if (seat.childLive) {
+        signalProcessFamily(seat.childPid, "SIGHUP");
+        signalProcessFamily(seat.childPid, "SIGTERM");
+        if (!seat.wrapperLive) {
+          signalProcessFamily(seat.childPid, "SIGKILL");
         }
-      } else {
-        seat.wrapperForced = false;
       }
 
-      if (seat.childPid && isPidAlive(seat.childPid)) {
-        try {
-          process.kill(seat.childPid, "SIGKILL");
-          seat.childForced = true;
-        } catch (error) {
-          seat.childForced = false;
-        }
-      } else {
-        seat.childForced = false;
+      if (seat.wrapperLive) {
+        signalPid(seat.wrapperPid, "SIGTERM");
       }
     }
   }
 
   return {
-    sessionName,
-    sessions: sessionResults,
+    requestedAt,
+    sessions: report.sessions,
   };
 }
 
-function readSessionStatus(sessionName) {
-  return {
-    sessionName,
-    seats: [1, 2].map((seatId) => {
-      const paths = getSeatPaths(sessionName, seatId);
-      const status = readJson(paths.statusPath, null);
-      return {
-        seatId,
-        status,
-      };
-    }),
-  };
+module.exports = {
+  ArmedSeat,
+  getStatusReport,
+  resolveSessionName,
+  stopAllSessions,
+};
+
+function signalPid(pid, signal) {
+  if (!Number.isInteger(pid) || pid <= 0 || !isPidAlive(pid)) {
+    return false;
+  }
+
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-function readAllSessionStatuses() {
-  return listSessionNames().map((sessionName) => readSessionStatus(sessionName));
+function signalProcessTree(rootPid, signal) {
+  if (!Number.isInteger(rootPid) || rootPid <= 0) {
+    return 0;
+  }
+
+  let delivered = 0;
+  for (const process of getChildProcesses(rootPid)) {
+    if (signalPid(process.pid, signal)) {
+      delivered += 1;
+    }
+  }
+
+  if (signalPid(rootPid, signal)) {
+    delivered += 1;
+  }
+
+  return delivered;
 }
 
-module.exports = {
-  SeatProcess,
-  formatCommand,
-  readAllSessionStatuses,
-  readSessionStatus,
-  resolveProgramTokens,
-  resolveSessionName,
-  stopSession,
-  stopSessions,
-};
+function signalProcessGroup(rootPid, signal) {
+  if (!Number.isInteger(rootPid) || rootPid <= 0) {
+    return false;
+  }
+
+  try {
+    process.kill(-rootPid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function signalProcessFamily(rootPid, signal) {
+  let delivered = 0;
+  if (signalProcessGroup(rootPid, signal)) {
+    delivered += 1;
+  }
+  delivered += signalProcessTree(rootPid, signal);
+  return delivered;
+}
+
+function clearStaleStopRequest(stopPath, startedAtMs) {
+  const request = readJson(stopPath, null);
+  if (!request?.requestedAt) {
+    return;
+  }
+
+  const requestedAtMs = Date.parse(request.requestedAt);
+  if (Number.isFinite(requestedAtMs) && requestedAtMs <= startedAtMs) {
+    fs.rmSync(stopPath, { force: true });
+  }
+}
+
+function selectVisibleStopRequest(requestedAt, seats) {
+  if (!requestedAt) {
+    return null;
+  }
+
+  const requestedAtMs = Date.parse(requestedAt);
+  if (!Number.isFinite(requestedAtMs)) {
+    return null;
+  }
+
+  const newestStartedAtMs = seats
+    .map((seat) => Date.parse(seat.startedAt || ""))
+    .filter((value) => Number.isFinite(value))
+    .sort((left, right) => right - left)[0];
+
+  if (Number.isFinite(newestStartedAtMs) && requestedAtMs <= newestStartedAtMs) {
+    return null;
+  }
+
+  return requestedAt;
+}