muuuuse 5.0.2 → 5.5.4

package/README.md

@@ -1,44 +1,56 @@
 # 🔌Muuuuse
 
-`🔌Muuuuse` is a tiny terminal relay with flexible routing.
+`🔌Muuuuse` is a tiny terminal relay.
 
 It does one job:
-- arm any number of terminals with `muuuuse <N>`
-- each seat can route to any other seats with individual flow modes
+- arm terminal one with `muuuuse 1`
+- arm terminal two with `muuuuse 2`
+- have seat 1 generate a session key and seat 2 sign it
+- additional isolated pairs work the same way: `3/4`, `5/6`, `7/8`, ...
+- choose per-seat relay mode with `flow on` or `flow off`
 - watch Codex, Claude, or Gemini for local assistant output
-- relay that output to configured targets with per-target flow control
+- 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 1 flow off
+muuuuse 1 flow off continue 5
 muuuuse 2
-muuuuse 3 link 1 flow on 2 flow off
-muuuuse 4 link 3 flow on
+muuuuse 2 flow off
+muuuuse 2 flow on continue 3
+muuuuse 3
+muuuuse 3 flow on
+muuuuse 4
+muuuuse 4 flow off continue 1
 muuuuse status
 muuuuse stop
 ```
 
-## Routing
+## Flow
 
-Any seat can route to any targets. Syntax:
+Terminal 1:
 
 ```bash
-muuuuse <seat> link <target1> flow <on|off> [<target2> flow <on|off> ...]
+muuuuse 1 flow on
 ```
 
-Example: Seat 3 routes to seat 1 with full output (flow on) and seat 4 with final answers only (flow off):
+Terminal 2:
 
 ```bash
-muuuuse 3 link 1 flow on 4 flow off
+muuuuse 2 flow off
 ```
 
-Each seat defines its own routing targets. When that seat gets an answer from Claude/Codex/Gemini, it sends to all configured targets with their respective flow modes.
+Now both shells are armed. `muuuuse 1` generates the session key, `muuuuse 2` signs it, and only that signed pair relays. Every odd/even adjacent pair works the same way in parallel: `3/4`, `5/6`, `7/8`, and so on. Use those shells normally.
 
-`flow on` means relay both thinking/commentary and final answers. `flow off` means relay final answers only.
+`flow on` means that seat relays commentary and final answers. `flow off` means that seat relays and accepts final answers only. Mixed calibration is allowed per seat.
 
-If you want Codex in one and Gemini in another, start them inside the armed shells:
+`continue <seat>` forwards that seat's relayed output into another armed seat without changing the signed odd/even pair law. This lets you build local loops like `1 -> 2 -> 3 -> 4 -> 1` while every adjacent pair still keeps its own session keypair.
+
+If you want Codex in one and Gemini in the other, start them inside the armed shells:
 
 ```bash
 codex
@@ -48,7 +60,7 @@ codex
 gemini
 ```
 
-`🔌Muuuuse` tails the local session logs for supported CLIs, relays according to each target's flow mode, types that output into the target 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:
 
@@ -65,9 +77,8 @@ muuuuse stop
 ## Notes
 
 - state lives under `~/.muuuuse`
-- each seat defines its own routing targets independently
-- any seat can route to any other seat number
-- flow modes are per-target (not per-seat)
+- only the signed armed pair can exchange relay events
+- `continue <seat>` is a separate local forwarding lane and can target any armed seat number
 - supported relay detection is built for Codex, Claude, and Gemini
 
 ## Install

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "5.0.2",
-  "description": "🔌Muuuuse arms terminals with flexible routing to any targets - pure message relay graph.",
+  "version": "5.5.4",
+  "description": "🔌Muuuuse arms regular terminals in isolated pairs and can continue relay output into any other armed seat.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"

package/src/agents.js

@@ -69,44 +69,6 @@ function detectAgent(processes) {
       return buildDetectedAgent("gemini", process);
     }
   }
-
-  // Fallback: if no agent process found, check for Claude Code running in a separate terminal
-  // (Claude Code's session updates even if it's not a child process of this shell)
-  if (processes.length > 0) {
-    // Use the bash/shell process as reference for timing
-    const shellProcess = processes[0];
-    const now = Date.now();
-    const recentThreshold = now - 2 * 60 * 1000; // Last 2 minutes
-
-    const CLAUDE_ROOT = path.join(os.homedir(), ".claude", "projects");
-    if (fs.existsSync(CLAUDE_ROOT)) {
-      try {
-        const sessionFiles = walkFiles(CLAUDE_ROOT, (f) => f.endsWith(".jsonl"))
-          .map(filePath => {
-            try {
-              const stat = fs.statSync(filePath);
-              return { filePath, mtimeMs: stat.mtimeMs };
-            } catch {
-              return null;
-            }
-          })
-          .filter(e => e && e.mtimeMs > recentThreshold)
-          .sort((a, b) => b.mtimeMs - a.mtimeMs)[0];
-
-        if (sessionFiles) {
-          return {
-            type: "claude",
-            pid: process.pid || shellProcess.pid,
-            args: "claude-code-terminal-session",
-            cwd: shellProcess.cwd || null,
-            elapsedSeconds: Math.round((Date.now() - shellProcess.startedAtMs) / 1000),
-            processStartedAtMs: Date.now() - (shellProcess.elapsedSeconds ?? 0) * 1000,
-          };
-        }
-      } catch {}
-    }
-  }
-
   return null;
 }
 
@@ -593,7 +555,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 "";
   }
@@ -606,23 +569,7 @@ function extractClaudeAssistantText(content) {
       if (item.type === "text" && typeof item.text === "string") {
         return [item.text.trim()];
       }
-      return [];
-    })
-    .filter((text) => text.length > 0)
-    .join("\n");
-}
-
-function extractClaudeThinkingText(content) {
-  if (!Array.isArray(content)) {
-    return "";
-  }
-
-  return content
-    .flatMap((item) => {
-      if (!item || typeof item !== "object") {
-        return [];
-      }
-      if (item.type === "thinking" && typeof item.thinking === "string") {
+      if (flowMode && item.type === "thinking" && typeof item.thinking === "string") {
         return [item.thinking.trim()];
       }
       return [];
@@ -639,46 +586,28 @@ function parseClaudeAssistantLine(line, options = {}) {
       return null;
     }
 
-    const isFinal = entry.message?.stop_reason === "end_turn";
-    if (!flowMode && !isFinal) {
+    if (!flowMode && entry.message?.stop_reason !== "end_turn") {
       return null;
     }
 
-    const id = entry.uuid || entry.message.id || hashText(line);
-    const timestamp = entry.timestamp || new Date().toISOString();
-    const results = [];
-
-    if (flowMode) {
-      const thinking = sanitizeRelayText(extractClaudeThinkingText(entry.message.content));
-      if (thinking) {
-        results.push({
-          id: `${id}-thinking`,
-          text: thinking,
-          phase: "commentary",
-          timestamp,
-        });
-      }
-    }
-
-    const text = sanitizeRelayText(extractClaudeAssistantText(entry.message.content));
-    if (text) {
-      results.push({
-        id,
-        text,
-        phase: isFinal ? "final_answer" : "commentary",
-        timestamp,
-      });
+    const text = sanitizeRelayText(extractClaudeAssistantText(entry.message.content, options));
+    if (!text) {
+      return null;
     }
 
-    return results.length > 0 ? results : null;
+    return {
+      id: entry.uuid || entry.message.id || hashText(line),
+      text,
+      phase: flowMode && entry.message?.stop_reason !== "end_turn" ? "commentary" : "final_answer",
+      timestamp: entry.timestamp || new Date().toISOString(),
+    };
   } catch {
     return null;
   }
 }
 
 function parseClaudeFinalLine(line) {
-  const results = parseClaudeAssistantLine(line, { flowMode: false });
-  return Array.isArray(results) ? results[0] || null : results;
+  return parseClaudeAssistantLine(line, { flowMode: false });
 }
 
 function readClaudeAnswers(filePath, offset, sinceMs = null, options = {}) {
@@ -687,10 +616,8 @@ function readClaudeAnswers(filePath, offset, sinceMs = null, options = {}) {
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.length > 0)
-    .flatMap((line) => {
-      const result = parseClaudeAssistantLine(line, options);
-      return Array.isArray(result) ? result : result ? [result] : [];
-    })
+    .map((line) => parseClaudeAssistantLine(line, options))
+    .filter((entry) => entry !== null)
     .filter((entry) => isAnswerNewEnough(entry, sinceMs));
 
   return { nextOffset, answers };

package/src/cli.js

@@ -56,10 +56,11 @@ async function main(argv = process.argv.slice(2)) {
 
   const seatId = normalizeSeatId(command);
   if (seatId) {
-    const { flowMode, continueTargets } = parseSeatOptions(command, argv.slice(1));
+    const { flowMode, continueSeatId, continueTargets } = parseSeatOptions(command, argv.slice(1));
     const seat = new ArmedSeat({
       cwd: process.cwd(),
       continueTargets,
+      continueSeatId,
       flowMode,
       seatId,
     });
@@ -105,60 +106,117 @@ function renderSeatStatus(seat) {
 }
 
 function renderLinkTargets(seat) {
-  const targets = Array.isArray(seat.continueTargets) ? seat.continueTargets : [];
-  if (targets.length === 0) {
-    return "";
+  const targets = [];
+  if (seat.partnerSeatId) {
+    targets.push({
+      targetSeatId: seat.partnerSeatId,
+      flowMode: seat.flowMode || "off",
+    });
+  }
+  for (const target of Array.isArray(seat.continueTargets) ? seat.continueTargets : []) {
+    targets.push(target);
   }
-  return targets.map((target) => `${target.targetSeatId}:${target.flowMode}`).join(", ");
+
+  return targets
+    .map((target) => `${target.targetSeatId}:${target.flowMode}`)
+    .join(", ");
 }
 
 function parseSeatOptions(command, args) {
   const seatId = normalizeSeatId(command);
   let flowMode = "off";
+  let continueSeatId = null;
   let continueTargets = [];
-  if (args.length === 0) {
-    return { flowMode, continueTargets };
-  }
+  let index = 0;
 
-  if (String(args[0] || "").trim().toLowerCase() === "link") {
-    const parsedLinks = parseLinkTargets(args.slice(1), seatId, flowMode);
-    if (parsedLinks.consumed === args.length - 1 && parsedLinks.consumed > 0) {
-      return {
-        flowMode: parsedLinks.flowMode,
-        continueTargets: parsedLinks.continueTargets,
-      };
-    }
-  } else {
-    let index = 0;
-
-    const flowToken = String(args[index] || "").trim().toLowerCase();
-    const flowModeToken = String(args[index + 1] || "").trim().toLowerCase();
-    if (flowToken === "flow" && (flowModeToken === "on" || flowModeToken === "off")) {
-      flowMode = flowModeToken;
-      index += 2;
+  while (index < args.length) {
+    const token = String(args[index] || "").trim().toLowerCase();
+
+    if (token === "flow") {
+      const flowToken = String(args[index + 1] || "").trim().toLowerCase();
+      if (flowToken === "on" || flowToken === "off") {
+        flowMode = flowToken;
+        index += 2;
+        continue;
+      }
+      break;
     }
 
-    const continueToken = String(args[index] || "").trim().toLowerCase();
-    const targetSeatId = normalizeSeatId(args[index + 1]);
-    if (continueToken === "continue" && targetSeatId) {
-      continueTargets = [{ targetSeatId, flowMode }];
-      index += 2;
+    if (token === "continue") {
+      const parsedTargets = parseContinueTargets(args.slice(index + 1), flowMode);
+      if (parsedTargets.targets.length > 0) {
+        continueTargets = mergeTargets(continueTargets, parsedTargets.targets);
+        continueSeatId = continueTargets[0].targetSeatId;
+        index += 1 + parsedTargets.consumed;
+        continue;
+      }
+      break;
     }
 
-    if (index === args.length) {
-      return { flowMode, continueTargets };
+    if (token === "link") {
+      const parsedLinks = parseLinkTargets(args.slice(index + 1), seatId, flowMode);
+      if (parsedLinks.consumed > 0) {
+        flowMode = parsedLinks.flowMode;
+        continueTargets = mergeTargets(continueTargets, parsedLinks.continueTargets);
+        continueSeatId = continueTargets[0]?.targetSeatId || null;
+        index += 1 + parsedLinks.consumed;
+        continue;
+      }
+      break;
     }
+
+    break;
+  }
+
+  if (index === args.length) {
+    return { flowMode, continueSeatId, continueTargets };
   }
 
   throw new Error(
-    `\`muuuuse ${command}\` accepts no extra arguments or \`link <seat> flow on [<seat> flow off ...]\`. Run it directly in the terminal you want to arm.`
+    `\`muuuuse ${command}\` accepts no extra arguments, \`flow on\` / \`flow off\`, optional \`continue <seat>\`, or \`link <seat> flow on [<seat> flow off ...]\`. Run it directly in the terminal you want to arm.`
   );
 }
 
-function parseLinkTargets(args, seatId, defaultFlowMode) {
+function mergeTargets(existingTargets, nextTargets) {
+  const merged = [];
+  for (const target of Array.isArray(existingTargets) ? existingTargets : []) {
+    upsertTarget(merged, target);
+  }
+  for (const target of Array.isArray(nextTargets) ? nextTargets : []) {
+    upsertTarget(merged, target);
+  }
+
+  return merged;
+}
+
+function parseContinueTargets(args, defaultFlowMode) {
   const targets = [];
   let consumed = 0;
 
+  while (consumed < args.length) {
+    const targetSeatId = normalizeSeatId(args[consumed]);
+    if (!targetSeatId) {
+      break;
+    }
+
+    const nextFlowMode = parseFlowModeToken(args[consumed + 1], args[consumed + 2]);
+    const target = {
+      targetSeatId,
+      flowMode: nextFlowMode || defaultFlowMode,
+    };
+    upsertTarget(targets, target);
+    consumed += nextFlowMode ? 3 : 1;
+  }
+
+  return { consumed, targets };
+}
+
+function parseLinkTargets(args, seatId, defaultFlowMode) {
+  const partnerSeatId = seatId ? getPartnerSeatId(seatId) : null;
+  const continueTargets = [];
+  let flowMode = defaultFlowMode;
+  let consumed = 0;
+
   while (consumed < args.length) {
     const targetSeatId = normalizeSeatId(args[consumed]);
     if (!targetSeatId) {
@@ -170,15 +228,19 @@ function parseLinkTargets(args, seatId, defaultFlowMode) {
       break;
     }
 
-    upsertTarget(targets, {
-      targetSeatId,
-      flowMode: targetFlowMode,
-    });
+    if (targetSeatId === partnerSeatId) {
+      flowMode = targetFlowMode;
+    } else {
+      upsertTarget(continueTargets, {
+        targetSeatId,
+        flowMode: targetFlowMode,
+      });
+    }
 
     consumed += 3;
   }
 
-  return { consumed, continueTargets: targets, flowMode: defaultFlowMode };
+  return { consumed, continueTargets, flowMode };
 }
 
 function parseFlowModeToken(flowToken, modeToken) {
@@ -201,5 +263,4 @@ function upsertTarget(targets, nextTarget) {
 
 module.exports = {
   main,
-  parseSeatOptions,
 };

package/src/runtime.js

@@ -42,7 +42,6 @@ const {
 
 const TYPE_CHUNK_DELAY_MS = 18;
 const TYPE_CHUNK_SIZE = 24;
-const TYPE_SUBMIT_DELAY_MS = 60;
 const MIRROR_SUPPRESSION_WINDOW_MS = 30 * 1000;
 const PENDING_RELAY_CONTEXT_TTL_MS = 2 * 60 * 1000;
 const EMITTED_ANSWER_TTL_MS = 5 * 60 * 1000;
@@ -57,32 +56,6 @@ const CHILD_ENV_DROP_KEYS = [
   "CODEX_THREAD_ID",
 ];
 
-function bestEffortEnableChildEcho(child) {
-  const ptsName = String(child?.ptsName || "").trim();
-  if (!ptsName || process.platform === "win32") {
-    return;
-  }
-
-  try {
-    execFileSync("stty", [
-      "-F",
-      ptsName,
-      "echo",
-      "icanon",
-      "isig",
-      "iexten",
-      "echoe",
-      "echok",
-      "echoke",
-      "echoctl",
-    ], {
-      stdio: "ignore",
-    });
-  } catch {
-    // Best effort only. The shell or child app may later change its own tty mode.
-  }
-}
-
 function normalizeFlowMode(flowMode) {
   return String(flowMode || "").trim().toLowerCase() === "on" ? "on" : "off";
 }
@@ -92,26 +65,6 @@ function normalizeContinueSeatId(value) {
   return seatId || null;
 }
 
-function normalizeContinueTargets(targets, defaultFlowMode = "off") {
-  const normalized = [];
-  const seen = new Set();
-
-  for (const entry of Array.isArray(targets) ? targets : []) {
-    const targetSeatId = normalizeSeatId(entry?.targetSeatId ?? entry?.seatId ?? entry);
-    if (!targetSeatId || seen.has(targetSeatId)) {
-      continue;
-    }
-
-    seen.add(targetSeatId);
-    normalized.push({
-      targetSeatId,
-      flowMode: normalizeFlowMode(entry?.flowMode ?? entry?.flow ?? defaultFlowMode),
-    });
-  }
-
-  return normalized;
-}
-
 function resolveShell() {
   const shell = String(process.env.SHELL || "").trim();
   return shell || "/bin/bash";
@@ -222,12 +175,7 @@ function findJoinableSessionName(currentPath = process.cwd(), seatId = 2) {
       const stopRequestedAtMs = Date.parse(stopRequest?.requestedAt || "");
       const createdAtMs = Date.parse(controller?.createdAt || anchorMeta?.startedAt || anchorStatus?.updatedAt || "");
 
-      // Accept session if: controller exists AND (anchor is live OR anchor has written meta/status files).
-      // This handles the startup race: anchor might not have a live PID yet, but if it wrote files, it's initialized.
-      const controllerExists = controller !== null;
-      const anchorInitialized = anchorMeta !== null || anchorStatus !== null;
-      const anchorReady = anchorLive || anchorInitialized;
-      if (!controllerExists || !anchorReady || seatLive) {
+      if (!anchorLive || seatLive) {
         return null;
       }
 
@@ -497,7 +445,6 @@ function buildAnswerSignaturePayload(sessionName, challenge, entry) {
     seatId: entry.seatId,
     origin: entry.origin,
     phase: entry.phase || "final_answer",
-    flowMode: entry.flowMode || "off",
     createdAt: entry.createdAt,
     text: entry.text,
   });
@@ -517,7 +464,6 @@ function buildContinuationEntry(sourceSessionName, targetSeatId, entry) {
     chainId: entry.chainId,
     hop: entry.hop,
     sourceAnswerId: entry.id,
-    flowMode: entry.flowMode || null,
     publicKey: entry.publicKey || null,
     signature: entry.signature || null,
   };
@@ -626,14 +572,6 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
     return false;
   }
 
-  // Some TUIs treat fast, chunked relay typing as paste input and suppress an
-  // immediate Enter. A short settle delay keeps submit behavior reliable.
-  await sleep(TYPE_SUBMIT_DELAY_MS);
-
-  if (shouldAbort() || !child) {
-    return false;
-  }
-
   try {
     child.write("\r");
   } catch {
@@ -649,14 +587,10 @@ class ArmedSeat {
     this.partnerSeatId = getPartnerSeatId(options.seatId);
     this.anchorSeatId = isAnchorSeat(options.seatId) ? options.seatId : this.partnerSeatId;
     this.flowMode = normalizeFlowMode(options.flowMode);
-    this.continueTargets = normalizeContinueTargets(
-      options.continueTargets || (
-        options.continueSeatId ? [{ targetSeatId: options.continueSeatId, flowMode: options.flowMode }] : []
-      ),
-      this.flowMode
-    );
+    this.continueSeatId = normalizeContinueSeatId(options.continueSeatId);
+    this.continueTargets = Array.isArray(options.continueTargets) ? options.continueTargets : [];
     this.cwd = normalizeWorkingPath(options.cwd);
-    if (this.continueTargets.some((target) => target.targetSeatId === this.seatId)) {
+    if (this.continueSeatId === this.seatId || this.continueTargets.some((t) => t.targetSeatId === this.seatId)) {
       throw new Error(`\`muuuuse ${this.seatId}\` cannot continue to itself.`);
     }
     this.sessionName = resolveSessionName(this.cwd, this.seatId);
@@ -732,6 +666,7 @@ class ArmedSeat {
       partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       flowMode: this.flowMode,
+      continueSeatId: this.continueSeatId,
       continueTargets: this.continueTargets,
       cwd: this.cwd,
       pid: process.pid,
@@ -748,6 +683,7 @@ class ArmedSeat {
       partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       flowMode: this.flowMode,
+      continueSeatId: this.continueSeatId,
       continueTargets: this.continueTargets,
       cwd: this.cwd,
       pid: process.pid,
@@ -941,7 +877,6 @@ class ArmedSeat {
       env: childEnv,
       name: childEnv.TERM,
     });
-    bestEffortEnableChildEcho(this.child);
 
     this.childPid = this.child.pid;
     this.writeMeta();
@@ -1094,23 +1029,19 @@ class ArmedSeat {
     return Number.isFinite(requestedAtMs) && requestedAtMs > this.startedAtMs;
   }
 
-  shouldCaptureCommentary() {
-    return this.flowMode === "on" || this.continueTargets.some((target) => target.flowMode === "on");
-  }
-
-  findContinuationTarget(targetSeatId) {
-    const normalizedTargetSeatId = normalizeSeatId(targetSeatId);
-    if (!normalizedTargetSeatId) {
+  findContinuationTarget(targetSeatId = null) {
+    const seatIdToFind = targetSeatId || this.continueSeatId;
+    if (!seatIdToFind) {
       return null;
     }
 
     const candidates = listSessionNames()
       .map((sessionName) => {
-        if (!getSeatDirIfExists(sessionName, normalizedTargetSeatId)) {
+        if (!getSeatDirIfExists(sessionName, seatIdToFind)) {
           return null;
         }
 
-        const seat = buildSeatReport(sessionName, normalizedTargetSeatId);
+        const seat = buildSeatReport(sessionName, seatIdToFind);
         if (!seat || !matchesWorkingPath(seat.cwd, this.cwd)) {
           return null;
         }
@@ -1151,8 +1082,7 @@ class ArmedSeat {
         return;
       }
 
-      const inboundFlowMode = normalizeFlowMode(entry.flowMode || this.flowMode);
-      if (!shouldAcceptInboundEntry(inboundFlowMode, entry)) {
+      if (!shouldAcceptInboundEntry(this.flowMode, entry)) {
         continue;
       }
 
@@ -1164,7 +1094,6 @@ class ArmedSeat {
         seatId: entry.seatId,
         origin: entry.origin || "unknown",
         phase: getRelayPhase(entry),
-        flowMode: inboundFlowMode,
         createdAt: entry.createdAt,
         text: payload,
       });
@@ -1220,8 +1149,7 @@ class ArmedSeat {
         return;
       }
 
-      const continueFlowMode = normalizeFlowMode(entry.flowMode || this.flowMode);
-      if (!shouldAcceptInboundEntry(continueFlowMode, entry)) {
+      if (!shouldAcceptInboundEntry(this.flowMode, entry)) {
         continue;
       }
 
@@ -1433,13 +1361,12 @@ class ArmedSeat {
     }
 
     const answers = [];
-    const captureCommentary = this.shouldCaptureCommentary();
     if (detectedAgent.type === "codex") {
       const result = readCodexAnswers(
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: captureCommentary }
+        { flowMode: this.flowMode === "on" }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1448,7 +1375,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: captureCommentary }
+        { flowMode: this.flowMode === "on" }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1457,7 +1384,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.lastMessageId,
         this.liveState.captureSinceMs,
-        { flowMode: captureCommentary }
+        { flowMode: this.flowMode === "on" }
       );
       this.liveState.lastMessageId = result.lastMessageId;
       this.liveState.offset = result.fileSize;
@@ -1515,7 +1442,6 @@ class ArmedSeat {
       seatId: this.seatId,
       origin: entry.origin || "unknown",
       phase: entry.phase || "final_answer",
-      flowMode: this.flowMode,
       text: payload,
       createdAt: entry.createdAt || new Date().toISOString(),
       chainId: pendingInboundContext?.chainId || entry.chainId || entryId,
@@ -1527,35 +1453,38 @@ class ArmedSeat {
       buildAnswerSignaturePayload(this.sessionName, this.trustState.challenge, signedEntry),
       this.identity.privateKey
     );
-
     appendJsonl(this.paths.eventsPath, signedEntry);
-    this.routeToTargets(signedEntry);
+    this.forwardContinuation(signedEntry);
     this.rememberEmittedAnswer(answerKey);
+
     this.log(`[${this.seatId}] ${previewText(payload)}`);
   }
 
-  routeToTargets(signedEntry) {
-    if (this.continueTargets.length === 0) {
-      return;
+  forwardContinuation(signedEntry) {
+    // Route to legacy single continueSeatId if set
+    if (this.continueSeatId) {
+      const target = this.findContinuationTarget();
+      if (!target) {
+        this.log(`[${this.seatId}] continue ${this.continueSeatId} unavailable`);
+        return;
+      }
+
+      const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, signedEntry);
+      appendJsonl(target.paths.continuePath, continuationEntry);
+      this.log(`[${this.seatId} => ${target.seatId}] ${previewText(continuationEntry.text)}`);
     }
 
+    // Route to all continueTargets with per-target flow modes
     for (const targetEntry of this.continueTargets) {
-      if (!shouldAcceptInboundEntry(targetEntry.flowMode, signedEntry)) {
-        continue;
-      }
-
       const target = this.findContinuationTarget(targetEntry.targetSeatId);
       if (!target) {
         this.log(`[${this.seatId}] target ${targetEntry.targetSeatId} unavailable`);
         continue;
       }
 
-      const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, {
-        ...signedEntry,
-        flowMode: targetEntry.flowMode,
-      });
+      const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, signedEntry);
       appendJsonl(target.paths.continuePath, continuationEntry);
-      this.log(`[${this.seatId} => ${target.seatId} ${targetEntry.flowMode}] ${previewText(continuationEntry.text)}`);
+      this.log(`[${this.seatId} => ${target.seatId} (${targetEntry.flowMode})] ${previewText(continuationEntry.text)}`);
     }
   }
 
@@ -1605,10 +1534,12 @@ class ArmedSeat {
     this.log(`${BRAND} seat ${this.seatId} armed for ${this.sessionName}.`);
     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.continueSeatId) {
+      this.log(`Seat ${this.seatId} continues to seat ${this.continueSeatId}.`);
+    }
     if (this.continueTargets.length > 0) {
-      this.log(
-        `Seat ${this.seatId} continues to ${this.continueTargets.map((target) => `seat ${target.targetSeatId} (${target.flowMode})`).join(", ")}.`
-      );
+      const targets = this.continueTargets.map((t) => `${t.targetSeatId} (${t.flowMode})`).join(", ");
+      this.log(`Seat ${this.seatId} links to ${targets}.`);
     }
     if (isAnchorSeat(this.seatId)) {
       this.log(`Seat ${this.seatId} generated the session key and is waiting for seat ${this.partnerSeatId} to sign it.`);
@@ -1709,17 +1640,10 @@ function buildSeatReport(sessionName, seatId) {
 
   return {
     seatId,
-    partnerSeatId: status?.partnerSeatId || meta?.partnerSeatId || getPartnerSeatId(seatId),
     state: wrapperLive ? status?.state || "running" : "orphaned_child",
     flowMode: status?.flowMode || meta?.flowMode || "off",
-    continueTargets: normalizeContinueTargets(
-      status?.continueTargets || meta?.continueTargets || (
-        (status?.continueSeatId || meta?.continueSeatId)
-          ? [{ targetSeatId: status?.continueSeatId || meta?.continueSeatId, flowMode: status?.flowMode || meta?.flowMode || "off" }]
-          : []
-      ),
-      status?.flowMode || meta?.flowMode || "off"
-    ),
+    continueSeatId: status?.continueSeatId || meta?.continueSeatId || null,
+    continueTargets: status?.continueTargets || meta?.continueTargets || [],
     wrapperPid,
     childPid,
     wrapperLive,
@@ -1795,13 +1719,6 @@ function stopAllSessions() {
         signalPid(seat.wrapperPid, "SIGTERM");
       }
     }
-
-    // Clean up session directory so stale data doesn't bleed into next session.
-    try {
-      fs.rmSync(sessionPaths.dir, { recursive: true, force: true });
-    } catch {
-      // Best-effort cleanup.
-    }
   }
 
   return {

package/src/util.js

@@ -9,16 +9,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 
-function getBrand() {
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "../package.json"), "utf8"));
-    return `🔌Muuuuse v${pkg.version}`;
-  } catch {
-    return "🔌Muuuuse";
-  }
-}
-
-const BRAND = getBrand();
+const BRAND = "🔌Muuuuse";
 const POLL_MS = 220;
 const MAX_RELAY_CHARS = 4000;
 const SESSION_MATCH_WINDOW_MS = 5 * 60 * 1000;
@@ -291,29 +282,31 @@ function listSessionNames() {
 
 function usage() {
   return [
-    `${BRAND} arms terminals with flexible routing to any targets - pure message relay graph.`,
+    `${BRAND} arms regular terminals in isolated odd/even pairs and relays assistant output between each pair.`,
     "",
     "Usage:",
-    "  muuuuse",
     "  muuuuse 1",
-    "  muuuuse 1 link 2 flow off",
-    "  muuuuse 1 link 2 flow on",
-    "  muuuuse 1 link 2 flow on 3 flow off",
+    "  muuuuse 1 flow on",
+    "  muuuuse 1 flow off",
+    "  muuuuse 1 flow on continue 3",
     "  muuuuse 2",
+    "  muuuuse 2 flow on",
+    "  muuuuse 2 flow off",
+    "  muuuuse 2 flow on continue 3",
     "  muuuuse 3",
     "  muuuuse 4",
-    "  muuuuse 4 link 3 flow off 1 flow on",
+    "  muuuuse 4 flow on continue 1",
     "  muuuuse stop",
     "  muuuuse status",
     "",
     "Flow:",
-    "  1. Run `muuuuse 1` in terminal one, then `muuuuse 2` in terminal two.",
-    "  2. Bare seats default to final-only pair relay.",
+    "  1. Run `muuuuse 1` in terminal one.",
+    "  2. Run `muuuuse 2` in terminal two.",
     "  3. The odd seat generates the session key and the matching even seat signs it automatically.",
     "  4. Additional pairs work the same way: `3/4`, `5/6`, `7/8`...",
-    "  5. Use `link <seat> flow on [<seat> flow off ...]` to set each outbound route.",
-    "  6. Include the odd/even partner in `link` to set normal pair flow.",
-    "  7. Any extra linked seats receive routed copies with their own flow mode.",
+    "  5. Optional: arm each seat with `flow on` or `flow off`.",
+    "  6. Optional: add `continue <seat>` to forward that seat's relayed output into another armed seat.",
+    "  7. Use those armed shells normally.",
     "  8. `flow off` sends final answers only. `flow on` keeps assistant commentary bouncing.",
     "  9. Run `muuuuse status` or `muuuuse stop` from any shell.",
     "",