muuuuse 1.5.0 → 2.2.0

package/README.md

@@ -6,15 +6,18 @@ It does one job:
 - arm terminal one with `muuuuse 1`
 - arm terminal two with `muuuuse 2`
 - have seat 1 generate a session key and seat 2 sign it
-- watch Codex, Claude, or Gemini for real final answers
-- inject that final answer into the other armed terminal
+- choose per-seat relay mode with `flow on` or `flow off`
+- watch Codex, Claude, or Gemini for local assistant output
+- inject that output into the other armed terminal
 - keep looping until you stop it
 
 The whole surface is:
 
 ```bash
 muuuuse 1
+muuuuse 1 flow on
 muuuuse 2
+muuuuse 2 flow off
 muuuuse status
 muuuuse stop
 ```
@@ -24,17 +27,19 @@ muuuuse stop
 Terminal 1:
 
 ```bash
-muuuuse 1
+muuuuse 1 flow on
 ```
 
 Terminal 2:
 
 ```bash
-muuuuse 2
+muuuuse 2 flow off
 ```
 
 Now both shells are armed. `muuuuse 1` generates the session key, `muuuuse 2` signs it, and only that signed pair relays. Use those shells normally.
 
+`flow on` means that seat sends commentary and final answers. `flow off` means that seat waits for final answers only. Each seat decides what it sends out, so mixed calibration is allowed.
+
 If you want Codex in one and Gemini in the other, start them inside the armed shells:
 
 ```bash
@@ -45,7 +50,7 @@ codex
 gemini
 ```
 
-`🔌Muuuuse` tails the local session logs for supported CLIs, detects the final answer, types that answer into the other seat, and then sends Enter as a separate keystroke.
+`🔌Muuuuse` tails the local session logs for supported CLIs, relays according to each seat's flow mode, types that output into the other seat, and then sends Enter as a separate keystroke.
 
 Check the live state from any terminal:
 
@@ -64,7 +69,7 @@ muuuuse stop
 - no tmux
 - state lives under `~/.muuuuse`
 - only the signed armed pair can exchange relay events
-- supported final-answer detection is built for Codex, Claude, and Gemini
+- supported relay detection is built for Codex, Claude, and Gemini
 - `codeman` remains the larger transport/control layer; `muuuuse` stays local and minimal
 
 ## Install

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "1.5.0",
-  "description": "🔌Muuuuse arms two regular terminals and relays final answers between them.",
+  "version": "2.2.0",
+  "description": "🔌Muuuuse arms two regular terminals and relays assistant output between them.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"

package/src/agents.js

@@ -12,9 +12,11 @@ const {
 } = require("./util");
 
 const CODEX_ROOT = path.join(os.homedir(), ".codex", "sessions");
+const CODEX_SNAPSHOT_ROOT = path.join(os.homedir(), ".codex", "shell_snapshots");
 const CLAUDE_ROOT = path.join(os.homedir(), ".claude", "projects");
 const GEMINI_ROOT = path.join(os.homedir(), ".gemini", "tmp");
 const SESSION_START_EARLY_TOLERANCE_MS = 2 * 1000;
+const STRICT_SINGLE_CANDIDATE_EARLY_TOLERANCE_MS = 250;
 
 function walkFiles(rootPath, predicate, results = []) {
   try {
@@ -51,7 +53,11 @@ function buildDetectedAgent(type, process) {
 }
 
 function detectAgent(processes) {
-  const ordered = [...processes].sort((left, right) => left.elapsedSeconds - right.elapsedSeconds);
+  const ordered = [...processes].sort((left, right) => (
+    (left.depth ?? Number.MAX_SAFE_INTEGER) - (right.depth ?? Number.MAX_SAFE_INTEGER) ||
+    right.elapsedSeconds - left.elapsedSeconds ||
+    left.pid - right.pid
+  ));
   for (const process of ordered) {
     if (commandMatches(process.args, "codex")) {
       return buildDetectedAgent("codex", process);
@@ -93,6 +99,33 @@ function readFirstLines(filePath, maxLines = 20) {
   }
 }
 
+function sortSessionCandidates(candidates) {
+  return candidates
+    .slice()
+    .sort((left, right) => {
+      const leftDiff = Number.isFinite(left.diffMs) ? left.diffMs : Number.MAX_SAFE_INTEGER;
+      const rightDiff = Number.isFinite(right.diffMs) ? right.diffMs : Number.MAX_SAFE_INTEGER;
+      return (
+        leftDiff - rightDiff ||
+        right.startedAtMs - left.startedAtMs ||
+        right.mtimeMs - left.mtimeMs ||
+        left.path.localeCompare(right.path)
+      );
+    });
+}
+
+function annotateSessionCandidates(candidates, processStartedAtMs) {
+  return candidates.map((candidate) => ({
+    ...candidate,
+    diffMs: Number.isFinite(processStartedAtMs) && Number.isFinite(candidate.startedAtMs)
+      ? Math.abs(candidate.startedAtMs - processStartedAtMs)
+      : Number.POSITIVE_INFINITY,
+    relativeStartMs: Number.isFinite(processStartedAtMs) && Number.isFinite(candidate.startedAtMs)
+      ? candidate.startedAtMs - processStartedAtMs
+      : Number.NaN,
+  }));
+}
+
 function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs) {
   const cwdMatches = candidates.filter((candidate) => candidate.cwd === currentPath);
   if (cwdMatches.length === 0) {
@@ -107,12 +140,7 @@ function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs)
     return null;
   }
 
-  const preciseMatches = cwdMatches
-    .map((candidate) => ({
-      ...candidate,
-      diffMs: Math.abs(candidate.startedAtMs - processStartedAtMs),
-      relativeStartMs: candidate.startedAtMs - processStartedAtMs,
-    }))
+  const preciseMatches = annotateSessionCandidates(cwdMatches, processStartedAtMs)
     .filter((candidate) => (
       Number.isFinite(candidate.diffMs) &&
       Number.isFinite(candidate.relativeStartMs) &&
@@ -128,29 +156,98 @@ function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs)
   return null;
 }
 
-function listOpenFilePaths(pid, rootPath) {
-  if (!Number.isInteger(pid) || pid <= 0) {
-    return [];
+function readCodexSeatClaim(sessionId) {
+  if (!sessionId) {
+    return null;
   }
 
-  const fdRoot = `/proc/${pid}/fd`;
+  const snapshotPath = path.join(CODEX_SNAPSHOT_ROOT, `${sessionId}.sh`);
   try {
-    const rootPrefix = path.resolve(rootPath);
-    const openPaths = fs.readdirSync(fdRoot)
-      .map((entry) => {
-        try {
-          return fs.realpathSync(path.join(fdRoot, entry));
-        } catch {
-          return null;
-        }
-      })
-      .filter((entry) => typeof entry === "string")
-      .filter((entry) => entry.startsWith(rootPrefix));
+    const text = fs.readFileSync(snapshotPath, "utf8");
+    const seatMatch = text.match(/declare -x MUUUUSE_SEAT="([^"]+)"/);
+    const sessionMatch = text.match(/declare -x MUUUUSE_SESSION="([^"]+)"/);
+    if (!seatMatch || !sessionMatch) {
+      return null;
+    }
 
-    return [...new Set(openPaths)];
+    return {
+      seatId: seatMatch[1],
+      sessionName: sessionMatch[1],
+    };
   } catch {
+    return null;
+  }
+}
+
+function selectClaimedCodexCandidatePath(candidates, options = {}) {
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  if (!seatId || !sessionName || candidates.length <= 1) {
+    return null;
+  }
+
+  const annotated = candidates.map((candidate) => ({
+    ...candidate,
+    claim: readCodexSeatClaim(candidate.sessionId),
+  }));
+
+  const exactMatches = annotated.filter((candidate) => (
+    candidate.claim?.seatId === seatId &&
+    candidate.claim?.sessionName === sessionName
+  ));
+  if (exactMatches.length === 1) {
+    return exactMatches[0].path;
+  }
+
+  const otherSeatClaims = annotated.filter((candidate) => (
+    candidate.claim?.sessionName === sessionName &&
+    candidate.claim?.seatId !== seatId
+  ));
+  if (otherSeatClaims.length === 0) {
+    return null;
+  }
+
+  const foreignPaths = new Set(otherSeatClaims.map((candidate) => candidate.path));
+  const remaining = annotated.filter((candidate) => !foreignPaths.has(candidate.path));
+  if (remaining.length === 1) {
+    return remaining[0].path;
+  }
+
+  return null;
+}
+
+function listOpenFilePathsForPids(pids, rootPath) {
+  const normalizedPids = [...new Set(
+    (Array.isArray(pids) ? pids : [pids])
+      .map((pid) => Number.parseInt(pid, 10))
+      .filter((pid) => Number.isInteger(pid) && pid > 0)
+  )];
+  if (normalizedPids.length === 0) {
     return [];
   }
+
+  const rootPrefix = path.resolve(rootPath);
+  const openPaths = new Set();
+
+  for (const pid of normalizedPids) {
+    const fdRoot = `/proc/${pid}/fd`;
+    try {
+      for (const entry of fs.readdirSync(fdRoot)) {
+        try {
+          const resolved = fs.realpathSync(path.join(fdRoot, entry));
+          if (typeof resolved === "string" && resolved.startsWith(rootPrefix)) {
+            openPaths.add(resolved);
+          }
+        } catch {
+          // Ignore descriptors that disappear while we are inspecting them.
+        }
+      }
+    } catch {
+      // Ignore pids that have already exited.
+    }
+  }
+
+  return [...openPaths];
 }
 
 function selectLiveSessionCandidatePath(candidates, currentPath, captureSinceMs = null) {
@@ -173,8 +270,8 @@ function selectLiveSessionCandidatePath(candidates, currentPath, captureSinceMs
   return ranked[0]?.path || null;
 }
 
-function readOpenSessionCandidates(pid, rootPath, reader) {
-  return listOpenFilePaths(pid, rootPath)
+function readOpenSessionCandidates(pids, rootPath, reader) {
+  return listOpenFilePathsForPids(pids, rootPath)
     .map((filePath) => reader(filePath))
     .filter((candidate) => candidate !== null);
 }
@@ -195,6 +292,7 @@ function readCodexCandidate(filePath) {
       path: filePath,
       cwd: entry.payload.cwd,
       isSubagent: Boolean(entry.payload?.source?.subagent),
+      sessionId: entry.payload.id || null,
       startedAtMs: Date.parse(entry.payload.timestamp),
       mtimeMs: fs.statSync(filePath).mtimeMs,
     };
@@ -203,9 +301,131 @@ function readCodexCandidate(filePath) {
   }
 }
 
+function rankCodexCandidates(candidates, processStartedAtMs) {
+  return sortSessionCandidates(annotateSessionCandidates(candidates, processStartedAtMs));
+}
+
+function selectExactClaimedCodexCandidate(candidates, options = {}, processStartedAtMs = null) {
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  if (!seatId || !sessionName) {
+    return null;
+  }
+
+  const exactMatches = rankCodexCandidates(
+    candidates.filter((candidate) => {
+      const claim = readCodexSeatClaim(candidate.sessionId);
+      return claim?.seatId === seatId && claim?.sessionName === sessionName;
+    }),
+    processStartedAtMs
+  );
+
+  return exactMatches[0]?.path || null;
+}
+
+function filterForeignClaimedCodexCandidates(candidates, options = {}) {
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  if (!seatId || !sessionName) {
+    return candidates.slice();
+  }
+
+  return candidates.filter((candidate) => {
+    const claim = readCodexSeatClaim(candidate.sessionId);
+    return !(claim?.sessionName === sessionName && claim?.seatId && claim.seatId !== seatId);
+  });
+}
+
+function selectStrictSingleCodexCandidatePath(candidates, processStartedAtMs) {
+  if (candidates.length !== 1 || !Number.isFinite(processStartedAtMs)) {
+    return null;
+  }
+
+  const [candidate] = annotateSessionCandidates(candidates, processStartedAtMs);
+  if (!Number.isFinite(candidate.relativeStartMs)) {
+    return null;
+  }
+
+  if (
+    candidate.relativeStartMs < -STRICT_SINGLE_CANDIDATE_EARLY_TOLERANCE_MS ||
+    candidate.relativeStartMs > SESSION_MATCH_WINDOW_MS
+  ) {
+    return null;
+  }
+
+  return candidate.path;
+}
+
+function selectCodexCandidatePath(candidates, currentPath, processStartedAtMs, options = {}) {
+  const cwdMatches = candidates.filter((candidate) => candidate.cwd === currentPath);
+  if (cwdMatches.length === 0) {
+    return null;
+  }
+
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  const exactClaimPath = selectExactClaimedCodexCandidate(cwdMatches, options, processStartedAtMs);
+  if (exactClaimPath) {
+    return exactClaimPath;
+  }
+
+  const foreignClaimsPresent = Boolean(
+    seatId &&
+    sessionName &&
+    cwdMatches.some((candidate) => {
+      const claim = readCodexSeatClaim(candidate.sessionId);
+      return claim?.sessionName === sessionName && claim?.seatId && claim.seatId !== seatId;
+    })
+  );
+  const allowedMatches = filterForeignClaimedCodexCandidates(cwdMatches, options);
+  if (allowedMatches.length === 0) {
+    return null;
+  }
+
+  if (!Number.isFinite(processStartedAtMs)) {
+    return allowedMatches.length === 1 ? allowedMatches[0].path : null;
+  }
+
+  const preciseMatches = rankCodexCandidates(
+    allowedMatches.filter((candidate) => {
+      const annotated = annotateSessionCandidates([candidate], processStartedAtMs)[0];
+      return (
+        Number.isFinite(annotated.diffMs) &&
+        Number.isFinite(annotated.relativeStartMs) &&
+        annotated.relativeStartMs >= -SESSION_START_EARLY_TOLERANCE_MS &&
+        annotated.relativeStartMs <= SESSION_MATCH_WINDOW_MS
+      );
+    }),
+    processStartedAtMs
+  );
+
+  const preciseClaimPath = selectClaimedCodexCandidatePath(preciseMatches, options);
+  if (preciseClaimPath) {
+    return preciseClaimPath;
+  }
+
+  const pairedSeatSelection = seatId && sessionName;
+  if (pairedSeatSelection && options.allowUnclaimedSingleCandidate === false && !foreignClaimsPresent) {
+    return null;
+  }
+
+  if (preciseMatches.length === 1) {
+    return selectStrictSingleCodexCandidatePath(preciseMatches, processStartedAtMs);
+  }
+
+  if (allowedMatches.length === 1) {
+    return selectStrictSingleCodexCandidatePath(allowedMatches, processStartedAtMs);
+  }
+
+  return null;
+}
+
 function selectCodexSessionFile(currentPath, processStartedAtMs, options = {}) {
-  const liveCandidates = readOpenSessionCandidates(options.pid, CODEX_ROOT, readCodexCandidate);
-  const livePath = selectLiveSessionCandidatePath(liveCandidates, currentPath, options.captureSinceMs);
+  const liveCandidates = readOpenSessionCandidates(options.pids ?? options.pid, CODEX_ROOT, readCodexCandidate);
+  const livePath = selectCodexCandidatePath(liveCandidates, currentPath, processStartedAtMs, {
+    ...options,
+    allowUnclaimedSingleCandidate: true,
+  });
   if (livePath) {
     return livePath;
   }
@@ -214,7 +434,10 @@ function selectCodexSessionFile(currentPath, processStartedAtMs, options = {}) {
     .map((filePath) => readCodexCandidate(filePath))
     .filter((candidate) => candidate !== null);
 
-  return selectSessionCandidatePath(candidates, currentPath, processStartedAtMs);
+  return selectCodexCandidatePath(candidates, currentPath, processStartedAtMs, {
+    ...options,
+    allowUnclaimedSingleCandidate: false,
+  });
 }
 
 function extractCodexAssistantText(content) {
@@ -236,14 +459,17 @@ function extractCodexAssistantText(content) {
     .join("\n");
 }
 
-function parseCodexFinalLine(line) {
+function parseCodexAssistantLine(line, options = {}) {
+  const flowMode = options.flowMode === true;
   try {
     const entry = JSON.parse(line);
     if (entry?.type !== "response_item" || entry.payload?.type !== "message" || entry.payload?.role !== "assistant") {
       return null;
     }
 
-    if (entry.payload?.phase !== "final_answer") {
+    const phase = String(entry.payload?.phase || "").trim().toLowerCase();
+    const relayablePhase = phase === "final_answer" || (flowMode && phase === "commentary");
+    if (!relayablePhase) {
       return null;
     }
 
@@ -262,6 +488,10 @@ function parseCodexFinalLine(line) {
   }
 }
 
+function parseCodexFinalLine(line) {
+  return parseCodexAssistantLine(line, { flowMode: false });
+}
+
 function isAnswerNewEnough(answer, sinceMs = null) {
   if (!Number.isFinite(sinceMs)) {
     return true;
@@ -275,13 +505,13 @@ function isAnswerNewEnough(answer, sinceMs = null) {
   return answerMs >= sinceMs;
 }
 
-function readCodexAnswers(filePath, offset, sinceMs = null) {
+function readCodexAnswers(filePath, offset, sinceMs = null, options = {}) {
   const { nextOffset, text } = readAppendedText(filePath, offset);
   const answers = text
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.length > 0)
-    .map((line) => parseCodexFinalLine(line))
+    .map((line) => parseCodexAssistantLine(line, options))
     .filter((entry) => entry !== null)
     .filter((entry) => isAnswerNewEnough(entry, sinceMs));
 
@@ -311,7 +541,7 @@ function readClaudeCandidate(filePath) {
 }
 
 function selectClaudeSessionFile(currentPath, processStartedAtMs, options = {}) {
-  const liveCandidates = readOpenSessionCandidates(options.pid, CLAUDE_ROOT, readClaudeCandidate);
+  const liveCandidates = readOpenSessionCandidates(options.pids ?? options.pid, CLAUDE_ROOT, readClaudeCandidate);
   const livePath = selectLiveSessionCandidatePath(liveCandidates, currentPath, options.captureSinceMs);
   if (livePath) {
     return livePath;
@@ -324,7 +554,8 @@ function selectClaudeSessionFile(currentPath, processStartedAtMs, options = {})
   return selectSessionCandidatePath(candidates, currentPath, processStartedAtMs);
 }
 
-function extractClaudeAssistantText(content) {
+function extractClaudeAssistantText(content, options = {}) {
+  const flowMode = options.flowMode === true;
   if (!Array.isArray(content)) {
     return "";
   }
@@ -337,20 +568,28 @@ function extractClaudeAssistantText(content) {
       if (item.type === "text" && typeof item.text === "string") {
         return [item.text.trim()];
       }
+      if (flowMode && item.type === "thinking" && typeof item.thinking === "string") {
+        return [item.thinking.trim()];
+      }
       return [];
     })
     .filter((text) => text.length > 0)
     .join("\n");
 }
 
-function parseClaudeFinalLine(line) {
+function parseClaudeAssistantLine(line, options = {}) {
+  const flowMode = options.flowMode === true;
   try {
     const entry = JSON.parse(line);
-    if (entry?.type !== "assistant" || entry.message?.role !== "assistant" || entry.message?.stop_reason !== "end_turn") {
+    if (entry?.type !== "assistant" || entry.message?.role !== "assistant") {
       return null;
     }
 
-    const text = sanitizeRelayText(extractClaudeAssistantText(entry.message.content));
+    if (!flowMode && entry.message?.stop_reason !== "end_turn") {
+      return null;
+    }
+
+    const text = sanitizeRelayText(extractClaudeAssistantText(entry.message.content, options));
     if (!text) {
       return null;
     }
@@ -365,13 +604,17 @@ function parseClaudeFinalLine(line) {
   }
 }
 
-function readClaudeAnswers(filePath, offset, sinceMs = null) {
+function parseClaudeFinalLine(line) {
+  return parseClaudeAssistantLine(line, { flowMode: false });
+}
+
+function readClaudeAnswers(filePath, offset, sinceMs = null, options = {}) {
   const { nextOffset, text } = readAppendedText(filePath, offset);
   const answers = text
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.length > 0)
-    .map((line) => parseClaudeFinalLine(line))
+    .map((line) => parseClaudeAssistantLine(line, options))
     .filter((entry) => entry !== null)
     .filter((entry) => isAnswerNewEnough(entry, sinceMs));
 
@@ -397,7 +640,7 @@ function readGeminiCandidate(filePath) {
 
 function selectGeminiSessionFile(currentPath, processStartedAtMs, options = {}) {
   const projectHash = createHash("sha256").update(currentPath).digest("hex");
-  const liveCandidates = readOpenSessionCandidates(options.pid, GEMINI_ROOT, readGeminiCandidate)
+  const liveCandidates = readOpenSessionCandidates(options.pids ?? options.pid, GEMINI_ROOT, readGeminiCandidate)
     .filter((candidate) => candidate.projectHash === projectHash);
   const livePath = selectLiveSessionCandidatePath(liveCandidates, projectHash, options.captureSinceMs);
   if (livePath) {

package/src/cli.js

@@ -55,12 +55,10 @@ async function main(argv = process.argv.slice(2)) {
   }
 
   if (command === "1" || command === "2") {
-    if (argv.length > 1) {
-      throw new Error(`\`muuuuse ${command}\` takes no extra arguments. Run it directly in the terminal you want to arm.`);
-    }
-
+    const flowMode = parseSeatFlowMode(command, argv.slice(1));
     const seat = new ArmedSeat({
       cwd: process.cwd(),
+      flowMode,
       seatId: Number(command),
     });
     const code = await seat.run();
@@ -74,6 +72,7 @@ function renderSeatStatus(seat) {
   const bits = [
     `seat ${seat.seatId}: ${seat.state}`,
     `agent ${seat.agent || "idle"}`,
+    `flow ${seat.flowMode || "off"}`,
     `relays ${seat.relayCount}`,
     `wrapper ${seat.wrapperPid || "-"}`,
     `child ${seat.childPid || "-"}`,
@@ -99,6 +98,23 @@ function renderSeatStatus(seat) {
   return output;
 }
 
+function parseSeatFlowMode(command, args) {
+  if (args.length === 0) {
+    return "off";
+  }
+
+  if (args.length === 2 && String(args[0]).trim().toLowerCase() === "flow") {
+    const flowMode = String(args[1]).trim().toLowerCase();
+    if (flowMode === "on" || flowMode === "off") {
+      return flowMode;
+    }
+  }
+
+  throw new Error(
+    `\`muuuuse ${command}\` accepts either no extra arguments or \`flow on\` / \`flow off\`. Run it directly in the terminal you want to arm.`
+  );
+}
+
 module.exports = {
   main,
 };

package/src/runtime.js

@@ -1,5 +1,6 @@
 const fs = require("node:fs");
 const { execFileSync } = require("node:child_process");
+const path = require("node:path");
 const pty = require("node-pty");
 
 const {
@@ -36,8 +37,23 @@ const {
 
 const TYPE_DELAY_MS = 70;
 const MIRROR_SUPPRESSION_WINDOW_MS = 30 * 1000;
+const PENDING_RELAY_CONTEXT_TTL_MS = 2 * 60 * 1000;
+const EMITTED_ANSWER_TTL_MS = 5 * 60 * 1000;
 const MAX_RECENT_INBOUND_RELAYS = 12;
+const MAX_RECENT_EMITTED_ANSWERS = 48;
+const MAX_RELAY_CHAIN_HOP = 1;
 const STOP_FORCE_KILL_MS = 1200;
+const SEAT_JOIN_WAIT_MS = 3000;
+const SEAT_JOIN_POLL_MS = 60;
+const CHILD_ENV_DROP_KEYS = [
+  "CODEX_CI",
+  "CODEX_MANAGED_BY_NPM",
+  "CODEX_THREAD_ID",
+];
+
+function normalizeFlowMode(flowMode) {
+  return String(flowMode || "").trim().toLowerCase() === "on" ? "on" : "off";
+}
 
 function resolveShell() {
   const shell = String(process.env.SHELL || "").trim();
@@ -52,16 +68,139 @@ function resolveShellArgs(shellPath) {
   return [];
 }
 
-function resolveChildTerm() {
-  const inherited = String(process.env.TERM || "").trim();
+function resolveChildTerm(sourceEnv = process.env) {
+  const inherited = String(sourceEnv.TERM || "").trim();
   if (inherited && inherited.toLowerCase() !== "dumb") {
     return inherited;
   }
   return "xterm-256color";
 }
 
-function resolveSessionName(currentPath = process.cwd()) {
-  return getDefaultSessionName(currentPath);
+function sanitizeChildPath(pathValue, homeDir) {
+  const arg0Root = path.join(homeDir, ".codex", "tmp", "arg0");
+  const entries = String(pathValue || "")
+    .split(path.delimiter)
+    .filter(Boolean)
+    .filter((entry) => {
+      const resolved = path.resolve(entry);
+      return resolved !== arg0Root && !resolved.startsWith(`${arg0Root}${path.sep}`);
+    });
+
+  return entries.join(path.delimiter);
+}
+
+function buildChildEnv(seatId, sessionName, cwd, baseEnv = process.env) {
+  const env = { ...baseEnv };
+  for (const key of CHILD_ENV_DROP_KEYS) {
+    delete env[key];
+  }
+
+  const homeDir = String(env.HOME || "").trim() || process.env.HOME || "/root";
+  env.PATH = sanitizeChildPath(env.PATH, homeDir);
+  env.PWD = cwd;
+  env.TERM = resolveChildTerm(baseEnv);
+  env.MUUUUSE_SEAT = String(seatId);
+  env.MUUUUSE_SESSION = sessionName;
+  return env;
+}
+
+function normalizeWorkingPath(currentPath = process.cwd()) {
+  try {
+    return fs.realpathSync(currentPath);
+  } catch {
+    return path.resolve(currentPath);
+  }
+}
+
+function matchesWorkingPath(leftPath, rightPath) {
+  if (!leftPath || !rightPath) {
+    return false;
+  }
+
+  return normalizeWorkingPath(leftPath) === normalizeWorkingPath(rightPath);
+}
+
+function createSessionName(currentPath = process.cwd()) {
+  return `${getDefaultSessionName(currentPath)}-${createId(6)}`;
+}
+
+function sleepSync(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return;
+  }
+
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function findJoinableSessionName(currentPath = process.cwd()) {
+  const candidates = listSessionNames()
+    .map((sessionName) => {
+      const sessionPaths = getSessionPaths(sessionName);
+      const controller = readJson(sessionPaths.controllerPath, null);
+      const seat1Paths = getSeatPaths(sessionName, 1);
+      const seat2Paths = getSeatPaths(sessionName, 2);
+      const seat1Meta = readJson(seat1Paths.metaPath, null);
+      const seat1Status = readJson(seat1Paths.statusPath, null);
+      const seat2Meta = readJson(seat2Paths.metaPath, null);
+      const seat2Status = readJson(seat2Paths.statusPath, null);
+      const stopRequest = readJson(sessionPaths.stopPath, null);
+
+      const cwd = controller?.cwd || seat1Status?.cwd || seat1Meta?.cwd || seat2Status?.cwd || seat2Meta?.cwd || null;
+      if (!matchesWorkingPath(cwd, currentPath)) {
+        return null;
+      }
+
+      const seat1WrapperPid = seat1Status?.pid || seat1Meta?.pid || null;
+      const seat1ChildPid = seat1Status?.childPid || seat1Meta?.childPid || null;
+      const seat2WrapperPid = seat2Status?.pid || seat2Meta?.pid || null;
+      const seat2ChildPid = seat2Status?.childPid || seat2Meta?.childPid || null;
+      const seat1Live = isPidAlive(seat1WrapperPid) || isPidAlive(seat1ChildPid);
+      const seat2Live = isPidAlive(seat2WrapperPid) || isPidAlive(seat2ChildPid);
+      const stopRequestedAtMs = Date.parse(stopRequest?.requestedAt || "");
+      const createdAtMs = Date.parse(controller?.createdAt || seat1Meta?.startedAt || seat1Status?.updatedAt || "");
+
+      if (!seat1Live || seat2Live) {
+        return null;
+      }
+
+      if (Number.isFinite(stopRequestedAtMs) && Number.isFinite(createdAtMs) && stopRequestedAtMs > createdAtMs) {
+        return null;
+      }
+
+      return {
+        sessionName,
+        createdAtMs,
+      };
+    })
+    .filter((entry) => entry !== null)
+    .sort((left, right) => right.createdAtMs - left.createdAtMs);
+
+  return candidates[0]?.sessionName || null;
+}
+
+function waitForJoinableSessionName(currentPath = process.cwd(), timeoutMs = SEAT_JOIN_WAIT_MS) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const sessionName = findJoinableSessionName(currentPath);
+    if (sessionName) {
+      return sessionName;
+    }
+    sleepSync(SEAT_JOIN_POLL_MS);
+  }
+
+  return null;
+}
+
+function resolveSessionName(currentPath = process.cwd(), seatId = 1) {
+  if (seatId === 1) {
+    return createSessionName(currentPath);
+  }
+
+  if (seatId === 2) {
+    return waitForJoinableSessionName(currentPath);
+  }
+
+  return createSessionName(currentPath);
 }
 
 function parseAnswerEntries(text) {
@@ -79,6 +218,51 @@ function parseAnswerEntries(text) {
     .filter((entry) => entry && entry.type === "answer" && typeof entry.text === "string");
 }
 
+function readSessionHeaderText(filePath, maxBytes = 16384) {
+  try {
+    const fd = fs.openSync(filePath, "r");
+    try {
+      const buffer = Buffer.alloc(maxBytes);
+      const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+      return buffer.toString("utf8", 0, bytesRead);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return "";
+  }
+}
+
+function readSessionFileStartedAtMs(agentType, filePath) {
+  try {
+    if (agentType === "gemini") {
+      const entry = JSON.parse(fs.readFileSync(filePath, "utf8"));
+      return Date.parse(entry.startTime || entry.lastUpdated || "");
+    }
+
+    const header = readSessionHeaderText(filePath);
+    const lines = header
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    for (const line of lines) {
+      const entry = JSON.parse(line);
+      if (agentType === "codex" && entry?.type === "session_meta") {
+        return Date.parse(entry.payload?.timestamp || "");
+      }
+
+      if (agentType === "claude") {
+        return Date.parse(entry.timestamp || entry.message?.timestamp || "");
+      }
+    }
+  } catch {
+    return Number.NaN;
+  }
+
+  return Number.NaN;
+}
+
 function readProcessCwd(pid) {
   if (!Number.isInteger(pid) || pid <= 0) {
     return null;
@@ -121,20 +305,25 @@ function getChildProcesses(rootPid) {
       .filter((entry) => entry !== null);
 
     const descendants = [];
-    const queue = [rootPid];
-    const seen = new Set(queue);
+    const queue = [{ pid: rootPid, depth: 0 }];
+    const seen = new Set([rootPid]);
 
     while (queue.length > 0) {
-      const parentPid = queue.shift();
+      const current = queue.shift();
+      const parentPid = current.pid;
       for (const process of processes) {
         if (process.ppid !== parentPid || seen.has(process.pid)) {
           continue;
         }
         seen.add(process.pid);
-        queue.push(process.pid);
+        queue.push({
+          pid: process.pid,
+          depth: current.depth + 1,
+        });
         descendants.push({
           ...process,
           cwd: readProcessCwd(process.pid),
+          depth: current.depth + 1,
         });
       }
     }
@@ -145,14 +334,40 @@ function getChildProcesses(rootPid) {
   }
 }
 
-function resolveSessionFile(agentType, agentPid, currentPath, captureSinceMs, processStartedAtMs) {
+function getProcessFamilyPids(processes, rootPid) {
+  if (!Number.isInteger(rootPid) || rootPid <= 0) {
+    return [];
+  }
+
+  const related = new Set([rootPid]);
+  const queue = [rootPid];
+
+  while (queue.length > 0) {
+    const parentPid = queue.shift();
+    for (const process of processes) {
+      if (process.ppid !== parentPid || related.has(process.pid)) {
+        continue;
+      }
+
+      related.add(process.pid);
+      queue.push(process.pid);
+    }
+  }
+
+  return [...related];
+}
+
+function resolveSessionFile(agentType, agentPid, currentPath, captureSinceMs, processStartedAtMs, seatContext = {}) {
   if (!currentPath) {
     return null;
   }
 
   const options = {
     pid: agentPid,
+    pids: seatContext.agentPids,
     captureSinceMs,
+    seatId: seatContext.seatId,
+    sessionName: seatContext.sessionName,
   };
 
   if (agentType === "codex") {
@@ -192,6 +407,8 @@ function buildAnswerSignaturePayload(sessionName, challenge, entry) {
     type: "muuuuse_answer",
     sessionName,
     challenge,
+    chainId: entry.chainId,
+    hop: entry.hop,
     id: entry.id,
     seatId: entry.seatId,
     origin: entry.origin,
@@ -219,35 +436,23 @@ function readSeatChallenge(paths, sessionName) {
 }
 
 async function sendTextAndEnter(child, text, shouldAbort = () => false) {
-  const lines = String(text || "").replace(/\r/g, "").split("\n");
+  const payload = String(text || "")
+    .replace(/\r/g, "")
+    .replace(/\s*\n+\s*/g, " ")
+    .replace(/[ \t]{2,}/g, " ")
+    .trim();
 
-  for (let index = 0; index < lines.length; index += 1) {
+  if (payload.length > 0) {
     if (shouldAbort() || !child) {
       return false;
     }
 
-    const line = lines[index];
-    if (line.length > 0) {
-      try {
-        child.write(line);
-      } catch {
-        return false;
-      }
-      await sleep(TYPE_DELAY_MS);
-    }
-
-    if (index < lines.length - 1) {
-      if (shouldAbort()) {
-        return false;
-      }
-
-      try {
-        child.write("\r");
-      } catch {
-        return false;
-      }
-      await sleep(TYPE_DELAY_MS);
+    try {
+      child.write(payload);
+    } catch {
+      return false;
     }
+    await sleep(TYPE_DELAY_MS);
   }
 
   if (shouldAbort() || !child) {
@@ -267,8 +472,12 @@ class ArmedSeat {
   constructor(options) {
     this.seatId = options.seatId;
     this.partnerSeatId = options.seatId === 1 ? 2 : 1;
-    this.cwd = options.cwd;
-    this.sessionName = resolveSessionName(this.cwd);
+    this.flowMode = normalizeFlowMode(options.flowMode);
+    this.cwd = normalizeWorkingPath(options.cwd);
+    this.sessionName = resolveSessionName(this.cwd, this.seatId);
+    if (!this.sessionName) {
+      throw new Error("No armed `muuuuse 1` seat is waiting in this cwd. Run `muuuuse 1` first.");
+    }
     this.sessionPaths = getSessionPaths(this.sessionName);
     this.paths = getSeatPaths(this.sessionName, this.seatId);
     this.partnerPaths = getSeatPaths(this.sessionName, this.partnerSeatId);
@@ -286,7 +495,10 @@ class ArmedSeat {
     this.resizeCleanup = null;
     this.forceKillTimer = null;
     this.identity = null;
+    this.lastUserInputAtMs = 0;
+    this.pendingInboundContext = null;
     this.recentInboundRelays = [];
+    this.recentEmittedAnswers = [];
     this.trustState = {
       challenge: null,
       peerPublicKey: null,
@@ -306,6 +518,20 @@ class ArmedSeat {
     };
   }
 
+  writeController(extra = {}) {
+    const current = readJson(this.sessionPaths.controllerPath, {});
+    writeJson(this.sessionPaths.controllerPath, {
+      sessionName: this.sessionName,
+      cwd: this.cwd,
+      createdAt: current.createdAt || this.startedAt,
+      updatedAt: new Date().toISOString(),
+      seat1Pid: this.seatId === 1 ? process.pid : current.seat1Pid || null,
+      seat2Pid: this.seatId === 2 ? process.pid : current.seat2Pid || null,
+      pid: this.seatId === 1 ? process.pid : current.pid || null,
+      ...extra,
+    });
+  }
+
   log(message) {
     process.stderr.write(`${message}\n`);
   }
@@ -315,6 +541,7 @@ class ArmedSeat {
       seatId: this.seatId,
       partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
+      flowMode: this.flowMode,
       cwd: this.cwd,
       pid: process.pid,
       childPid: this.childPid,
@@ -329,6 +556,7 @@ class ArmedSeat {
       seatId: this.seatId,
       partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
+      flowMode: this.flowMode,
       cwd: this.cwd,
       pid: process.pid,
       childPid: this.childPid,
@@ -509,20 +737,17 @@ class ArmedSeat {
     fs.rmSync(this.paths.pipePath, { force: true });
     clearStaleStopRequest(this.sessionPaths.stopPath, this.startedAtMs);
     this.initializeTrustMaterial();
+    this.writeController();
 
     const shell = resolveShell();
     const shellArgs = resolveShellArgs(shell);
+    const childEnv = buildChildEnv(this.seatId, this.sessionName, this.cwd);
     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(),
+      env: childEnv,
+      name: childEnv.TERM,
     });
 
     this.childPid = this.child.pid;
@@ -547,6 +772,8 @@ class ArmedSeat {
 
   installStdinProxy() {
     const handleData = (chunk) => {
+      this.lastUserInputAtMs = Date.now();
+      this.pendingInboundContext = null;
       if (!this.child) {
         return;
       }
@@ -687,6 +914,8 @@ class ArmedSeat {
 
       const payload = sanitizeRelayText(entry.text);
       const signaturePayload = buildAnswerSignaturePayload(this.sessionName, this.trustState.challenge, {
+        chainId: entry.chainId || entry.id,
+        hop: Number.isInteger(entry.hop) ? entry.hop : 0,
         id: entry.id,
         seatId: entry.seatId,
         origin: entry.origin || "unknown",
@@ -718,6 +947,14 @@ class ArmedSeat {
         return;
       }
 
+      const deliveredAtMs = Date.now();
+      this.pendingInboundContext = {
+        chainId: entry.chainId || entry.id,
+        deliveredAtMs,
+        expiresAtMs: deliveredAtMs + PENDING_RELAY_CONTEXT_TTL_MS,
+        hop: Number.isInteger(entry.hop) ? entry.hop : 0,
+        relayUsed: false,
+      };
       this.relayCount += 1;
       this.rememberInboundRelay(payload);
       this.log(`[${this.partnerSeatId} -> ${this.seatId}] ${previewText(payload)}`);
@@ -749,6 +986,37 @@ class ArmedSeat {
     );
   }
 
+  pruneRecentEmittedAnswers(now = Date.now()) {
+    this.recentEmittedAnswers = this.recentEmittedAnswers.filter(
+      (entry) => now - entry.timestampMs <= EMITTED_ANSWER_TTL_MS
+    );
+  }
+
+  hasRecentEmittedAnswer(answerKey) {
+    if (!answerKey) {
+      return false;
+    }
+
+    this.pruneRecentEmittedAnswers();
+    return this.recentEmittedAnswers.some((entry) => entry.key === answerKey);
+  }
+
+  rememberEmittedAnswer(answerKey) {
+    if (!answerKey) {
+      return;
+    }
+
+    this.pruneRecentEmittedAnswers();
+    this.recentEmittedAnswers.push({
+      key: answerKey,
+      timestampMs: Date.now(),
+    });
+
+    if (this.recentEmittedAnswers.length > MAX_RECENT_EMITTED_ANSWERS) {
+      this.recentEmittedAnswers = this.recentEmittedAnswers.slice(-MAX_RECENT_EMITTED_ANSWERS);
+    }
+  }
+
   takeMirroredInboundRelay(payload) {
     const normalized = sanitizeRelayText(payload);
     if (!normalized) {
@@ -766,8 +1034,28 @@ class ArmedSeat {
     return match;
   }
 
+  getPendingInboundContext() {
+    const context = this.pendingInboundContext;
+    if (!context) {
+      return null;
+    }
+
+    if (context.expiresAtMs <= Date.now()) {
+      this.pendingInboundContext = null;
+      return null;
+    }
+
+    if (this.lastUserInputAtMs > context.deliveredAtMs) {
+      this.pendingInboundContext = null;
+      return null;
+    }
+
+    return context;
+  }
+
   collectLiveAnswers() {
-    const detectedAgent = detectAgent(getChildProcesses(this.childPid));
+    const childProcesses = getChildProcesses(this.childPid);
+    const detectedAgent = detectAgent(childProcesses);
     if (!detectedAgent) {
       this.liveState = {
         type: null,
@@ -813,18 +1101,27 @@ class ArmedSeat {
       };
     }
 
-    if (!this.liveState.sessionFile) {
-      this.liveState.sessionFile = resolveSessionFile(
-        detectedAgent.type,
-        detectedAgent.pid,
-        currentPath,
-        this.liveState.captureSinceMs,
-        detectedAgent.processStartedAtMs
-      );
+    const agentPids = getProcessFamilyPids(childProcesses, detectedAgent.pid);
+    const resolvedSessionFile = resolveSessionFile(
+      detectedAgent.type,
+      detectedAgent.pid,
+      currentPath,
+      this.liveState.captureSinceMs,
+      detectedAgent.processStartedAtMs,
+      {
+        agentPids,
+        seatId: this.seatId,
+        sessionName: this.sessionName,
+      }
+    );
 
-      if (this.liveState.sessionFile) {
-        this.liveState.offset = 0;
-        this.liveState.lastMessageId = null;
+    if (resolvedSessionFile && resolvedSessionFile !== this.liveState.sessionFile) {
+      this.liveState.sessionFile = resolvedSessionFile;
+      this.liveState.offset = 0;
+      this.liveState.lastMessageId = null;
+      const sessionStartedAtMs = readSessionFileStartedAtMs(detectedAgent.type, resolvedSessionFile);
+      if (Number.isFinite(sessionStartedAtMs)) {
+        this.liveState.captureSinceMs = Math.min(this.liveState.captureSinceMs, sessionStartedAtMs);
       }
     }
 
@@ -843,7 +1140,8 @@ class ArmedSeat {
       const result = readCodexAnswers(
         this.liveState.sessionFile,
         this.liveState.offset,
-        this.liveState.captureSinceMs
+        this.liveState.captureSinceMs,
+        { flowMode: this.flowMode === "on" }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -851,7 +1149,8 @@ class ArmedSeat {
       const result = readClaudeAnswers(
         this.liveState.sessionFile,
         this.liveState.offset,
-        this.liveState.captureSinceMs
+        this.liveState.captureSinceMs,
+        { flowMode: this.flowMode === "on" }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -859,7 +1158,8 @@ class ArmedSeat {
       const result = readGeminiAnswers(
         this.liveState.sessionFile,
         this.liveState.lastMessageId,
-        this.liveState.captureSinceMs
+        this.liveState.captureSinceMs,
+        { flowMode: this.flowMode === "on" }
       );
       this.liveState.lastMessageId = result.lastMessageId;
       this.liveState.offset = result.fileSize;
@@ -895,19 +1195,39 @@ class ArmedSeat {
       return;
     }
 
+    const answerKey = buildAnswerKey(entry, payload);
+    if (this.hasRecentEmittedAnswer(answerKey)) {
+      this.log(`[${this.seatId}] suppressed duplicate final answer: ${previewText(payload)}`);
+      return;
+    }
+
     const mirroredInbound = this.takeMirroredInboundRelay(payload);
     if (mirroredInbound) {
       this.log(`[${this.seatId}] suppressed mirrored relay: ${previewText(payload)}`);
       return;
     }
 
+    const pendingInboundContext = this.getPendingInboundContext();
+    if (this.flowMode !== "on" && pendingInboundContext && pendingInboundContext.hop >= MAX_RELAY_CHAIN_HOP) {
+      this.log(`[${this.seatId}] suppressed relay loop: ${previewText(payload)}`);
+      return;
+    }
+
+    if (pendingInboundContext?.relayUsed) {
+      this.log(`[${this.seatId}] suppressed extra queued relay output: ${previewText(payload)}`);
+      return;
+    }
+
+    const entryId = entry.id || createId(12);
     const signedEntry = {
-      id: entry.id || createId(12),
+      id: entryId,
       type: "answer",
       seatId: this.seatId,
       origin: entry.origin || "unknown",
       text: payload,
       createdAt: entry.createdAt || new Date().toISOString(),
+      chainId: pendingInboundContext?.chainId || entry.chainId || entryId,
+      hop: pendingInboundContext ? pendingInboundContext.hop + 1 : 0,
       challenge: this.trustState.challenge,
       publicKey: this.identity.publicKey,
     };
@@ -916,6 +1236,10 @@ class ArmedSeat {
       this.identity.privateKey
     );
     appendJsonl(this.paths.eventsPath, signedEntry);
+    this.rememberEmittedAnswer(answerKey);
+    if (pendingInboundContext) {
+      pendingInboundContext.relayUsed = true;
+    }
 
     this.log(`[${this.seatId}] ${previewText(payload)}`);
   }
@@ -946,6 +1270,7 @@ class ArmedSeat {
     this.writeStatus({
       state: live.state,
       agent: live.agent,
+      flowMode: this.flowMode,
       cwd: live.cwd,
       log: live.log,
       lastAnswerAt: live.lastAnswerAt,
@@ -962,7 +1287,8 @@ class ArmedSeat {
     this.installResizeHandler();
 
     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("Use this shell normally. Codex, Claude, and Gemini relay automatically from their local session logs.");
+    this.log(`Seat ${this.seatId} relay mode is flow ${this.flowMode}.`);
     if (this.seatId === 1) {
       this.log("Seat 1 generated the session key and is waiting for seat 2 to sign it.");
     } else {
@@ -1028,6 +1354,17 @@ function previewText(text, maxLength = 88) {
   return `${compact.slice(0, maxLength - 3)}...`;
 }
 
+function buildAnswerKey(entry, payload) {
+  const origin = String(entry.origin || "unknown").trim() || "unknown";
+  const id = typeof entry.id === "string" ? entry.id.trim() : "";
+  if (id) {
+    return `${origin}:${id}`;
+  }
+
+  const createdAt = typeof entry.createdAt === "string" ? entry.createdAt : "";
+  return `${origin}:${createdAt}:${hashText(payload)}`;
+}
+
 function buildSeatReport(sessionName, seatId) {
   const paths = getSeatPaths(sessionName, seatId);
   const daemon = readJson(paths.daemonPath, null);
@@ -1051,6 +1388,7 @@ function buildSeatReport(sessionName, seatId) {
   return {
     seatId,
     state: wrapperLive ? status?.state || "running" : "orphaned_child",
+    flowMode: status?.flowMode || meta?.flowMode || "off",
     wrapperPid,
     childPid,
     wrapperLive,
@@ -1136,6 +1474,7 @@ function stopAllSessions() {
 
 module.exports = {
   ArmedSeat,
+  buildChildEnv,
   getStatusReport,
   resolveSessionName,
   stopAllSessions,

package/src/util.js

@@ -245,11 +245,15 @@ function listSessionNames() {
 
 function usage() {
   return [
-    `${BRAND} arms two regular terminals and relays final answers between them.`,
+    `${BRAND} arms two regular terminals and relays assistant output between them.`,
     "",
     "Usage:",
     "  muuuuse 1",
+    "  muuuuse 1 flow on",
+    "  muuuuse 1 flow off",
     "  muuuuse 2",
+    "  muuuuse 2 flow on",
+    "  muuuuse 2 flow off",
     "  muuuuse stop",
     "  muuuuse status",
     "",
@@ -257,9 +261,10 @@ function usage() {
     "  1. Run `muuuuse 1` in terminal one.",
     "  2. Run `muuuuse 2` in terminal two.",
     "  3. Seat 1 generates the session key and seat 2 signs it automatically.",
-    "  4. Use those armed shells normally.",
-    "  5. Codex, Claude, and Gemini final answers relay automatically from their local session logs.",
-    "  6. Run `muuuuse status` or `muuuuse stop` from any shell.",
+    "  4. Optional: arm each seat with `flow on` or `flow off`.",
+    "  5. Use those armed shells normally.",
+    "  6. `flow off` sends final answers only. `flow on` keeps assistant commentary bouncing.",
+    "  7. Run `muuuuse status` or `muuuuse stop` from any shell.",
     "",
     "Notes:",
     "  - No tmux.",