muuuuse 7.0.1 → 7.0.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "7.0.1",
-  "description": "🔌Muuuuse relay protocol for long-horizon zero-drift agentic code loops. Any seat relays to any other with per-target signed trust and flow control.",
+  "version": "7.0.2",
+  "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"
@@ -40,7 +40,8 @@
   ],
   "scripts": {
     "test": "node test/cli.test.js",
-    "pack:local": "npm pack"
+    "pack:local": "npm pack",
+    "prepublishOnly": "npm test"
   },
   "dependencies": {
     "node-pty": "^1.1.0"

package/src/agents.js

@@ -468,9 +468,7 @@ function parseCodexAssistantLine(line, options = {}) {
     }
 
     const phase = String(entry.payload?.phase || "").trim().toLowerCase();
-    // Newer Codex sessions can omit `payload.phase` for final answers.
-    const normalizedPhase = phase === "commentary" ? "commentary" : "final_answer";
-    const relayablePhase = normalizedPhase === "final_answer" || (flowMode && normalizedPhase === "commentary");
+    const relayablePhase = phase === "final_answer" || (flowMode && phase === "commentary");
     if (!relayablePhase) {
       return null;
     }
@@ -483,7 +481,7 @@ function parseCodexAssistantLine(line, options = {}) {
     return {
       id: entry.payload.id || hashText(line),
       text,
-      phase: normalizedPhase,
+      phase: phase === "commentary" ? "commentary" : "final_answer",
       timestamp: entry.timestamp || entry.payload.timestamp || new Date().toISOString(),
     };
   } catch {

package/src/cli.js

@@ -1,4 +1,4 @@
-const { BRAND, normalizeSeatId, usage } = require("./util");
+const { BRAND, getPartnerSeatId, normalizeSeatId, usage } = require("./util");
 const { ArmedSeat, getStatusReport, stopAllSessions } = require("./runtime");
 
 async function main(argv = process.argv.slice(2)) {
@@ -56,10 +56,12 @@ async function main(argv = process.argv.slice(2)) {
 
   const seatId = normalizeSeatId(command);
   if (seatId) {
-    const { continueTargets } = parseSeatOptions(command, argv.slice(1));
+    const { flowMode, continueSeatId, continueTargets } = parseSeatOptions(command, argv.slice(1));
     const seat = new ArmedSeat({
       cwd: process.cwd(),
+      continueSeatId,
       continueTargets,
+      flowMode,
       seatId,
     });
     const code = await seat.run();
@@ -73,14 +75,20 @@ 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 || "-"}`,
   ];
 
-  const renderedLinks = renderLinkTargets(seat);
-  if (renderedLinks) {
-    bits.push(`link ${renderedLinks}`);
+  if (seat.partnerLive) {
+    bits.push("peer live");
+  }
+  if (seat.continueSeatId) {
+    bits.push(`continue ${seat.continueSeatId}`);
+  }
+  if (Array.isArray(seat.continueTargets) && seat.continueTargets.length > 0) {
+    bits.push(`links ${renderLinkTargets(seat.continueTargets)}`);
   }
   if (seat.trust) {
     bits.push(`trust ${seat.trust}`);
@@ -99,41 +107,28 @@ function renderSeatStatus(seat) {
   return output;
 }
 
-function renderLinkTargets(seat) {
-  const targets = Array.isArray(seat.continueTargets) ? seat.continueTargets : [];
+function renderLinkTargets(targets) {
   return targets
-    .map((target) => `${target.targetSeatId} (flow ${target.flowMode})`)
+    .map((target) => `${target.seatId}:${target.flowMode}`)
     .join(", ");
 }
 
 function parseSeatOptions(command, args) {
   const seatId = normalizeSeatId(command);
+  const partnerSeatId = getPartnerSeatId(seatId);
+  let flowMode = "off";
+  let continueSeatId = null;
   let continueTargets = [];
   let index = 0;
-  let seatFlowMode = null;
-  let hasExplicitTarget = false;
-
-  const flowToken = String(args[index] || "").trim().toLowerCase();
-  if (flowToken === "flow") {
-    const parsedSeatFlow = parseFlowModeToken("flow", args[index + 1]);
-    if (!parsedSeatFlow) {
-      throw new Error(
-        `\`muuuuse ${command} flow\` requires \`on\` or \`off\`.`
-      );
-    }
-    seatFlowMode = parsedSeatFlow;
-    index += 2;
-  }
 
-  while (index < args.length) {
+  for (; index < args.length;) {
     const token = String(args[index] || "").trim().toLowerCase();
 
-    if (token === "link") {
-      const parsedLinks = parseLinkTargets(args.slice(index + 1), seatId);
-      if (parsedLinks.consumed > 0) {
-        continueTargets = mergeTargets(continueTargets, parsedLinks.continueTargets);
-        hasExplicitTarget = true;
-        index += 1 + parsedLinks.consumed;
+    if (token === "flow") {
+      const nextFlowMode = parseFlowModeToken(args[index + 1]);
+      if (nextFlowMode) {
+        flowMode = nextFlowMode;
+        index += 2;
         continue;
       }
       break;
@@ -141,15 +136,22 @@ function parseSeatOptions(command, args) {
 
     if (token === "continue") {
       const targetSeatId = normalizeSeatId(args[index + 1]);
-      if (!targetSeatId) {
+      if (targetSeatId && targetSeatId !== seatId) {
+        continueSeatId = targetSeatId;
+        index += 2;
+        continue;
+      }
+      break;
+    }
+
+    if (token === "link") {
+      const parsed = parseLinkTargets(seatId, partnerSeatId, args, index + 1);
+      if (!parsed) {
         break;
       }
-      upsertTarget(continueTargets, {
-        targetSeatId,
-        flowMode: seatFlowMode || "on",
-      });
-      hasExplicitTarget = true;
-      index += 2;
+
+      continueTargets = mergeTargets(continueTargets, parsed.continueTargets);
+      index = parsed.nextIndex;
       continue;
     }
 
@@ -157,77 +159,79 @@ function parseSeatOptions(command, args) {
   }
 
   if (index === args.length) {
-    if (seatFlowMode && !hasExplicitTarget) {
-      const partnerSeatId = seatId % 2 === 0 ? seatId - 1 : seatId + 1;
-      if (partnerSeatId > 0) {
-        upsertTarget(continueTargets, {
-          targetSeatId: partnerSeatId,
-          flowMode: seatFlowMode,
-        });
-      }
-    }
-    return { continueTargets };
+    return { flowMode, continueSeatId, continueTargets };
   }
 
   throw new Error(
-    `\`muuuuse ${command}\` accepts no extra arguments, optional \`flow on/off\`, \`continue <seat>\`, or \`link <seat> flow on [<seat> flow off ...]\`. Run it directly in the terminal you want to arm.`
+    `\`muuuuse ${command}\` accepts \`flow on\` / \`flow off\`, optional \`continue <seat>\`, and optional \`link <seat> flow on|off ...\` groups. Run it directly in the terminal you want to arm.`
   );
 }
 
-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);
+function mergeTargets(currentTargets, nextTargets) {
+  const merged = [...currentTargets];
+  for (const target of nextTargets) {
+    const currentIndex = merged.findIndex((entry) => entry.seatId === target.seatId);
+    if (currentIndex !== -1) {
+      merged.splice(currentIndex, 1);
+    }
+    merged.push(target);
   }
-
   return merged;
 }
 
-function parseLinkTargets(args, seatId) {
+function parseLinkTargets(seatId, partnerSeatId, args, startIndex) {
+  let index = startIndex;
   const continueTargets = [];
-  let consumed = 0;
 
-  while (consumed < args.length) {
-    const targetSeatId = normalizeSeatId(args[consumed]);
-    if (!targetSeatId) {
+  while (index < args.length) {
+    const targetSeatId = normalizeSeatId(args[index]);
+    if (!targetSeatId || targetSeatId === seatId) {
+      break;
+    }
+
+    if (String(args[index + 1] || "").trim().toLowerCase() !== "flow") {
       break;
     }
 
-    const targetFlowMode = parseFlowModeToken(args[consumed + 1], args[consumed + 2]);
+    const targetFlowMode = parseFlowModeToken(args[index + 2]);
     if (!targetFlowMode) {
       break;
     }
 
     upsertTarget(continueTargets, {
-      targetSeatId,
+      seatId: targetSeatId,
       flowMode: targetFlowMode,
     });
 
-    consumed += 3;
+    index += 3;
   }
 
-  return { consumed, continueTargets };
+  if (index === startIndex) {
+    return null;
+  }
+
+  return {
+    continueTargets,
+    nextIndex: index,
+  };
 }
 
-function parseFlowModeToken(flowToken, modeToken) {
-  const normalizedFlowToken = String(flowToken || "").trim().toLowerCase();
-  const normalizedModeToken = String(modeToken || "").trim().toLowerCase();
-  if (normalizedFlowToken === "flow" && (normalizedModeToken === "on" || normalizedModeToken === "off")) {
-    return normalizedModeToken;
+function parseFlowModeToken(value) {
+  const token = String(value || "").trim().toLowerCase();
+  if (token === "on" || token === "off") {
+    return token;
   }
   return null;
 }
 
 function upsertTarget(targets, nextTarget) {
-  const existingIndex = targets.findIndex((entry) => entry.targetSeatId === nextTarget.targetSeatId);
-  if (existingIndex >= 0) {
-    targets[existingIndex] = nextTarget;
+  const currentIndex = targets.findIndex((target) => target.seatId === nextTarget.seatId);
+  if (currentIndex === -1) {
+    targets.push(nextTarget);
     return;
   }
-  targets.push(nextTarget);
+
+  targets[currentIndex] = nextTarget;
 }
 
 module.exports = {

package/src/runtime.js

@@ -20,10 +20,12 @@ const {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
+  getPartnerSeatId,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,
   hashText,
+  isAnchorSeat,
   isPidAlive,
   listSeatIds,
   loadOrCreateSeatIdentity,
@@ -38,7 +40,8 @@ const {
   writeJson,
 } = require("./util");
 
-const TYPE_CHUNK_DELAY_MS = 18;
+// A short settle delay keeps interactive CLIs from treating submit as another newline.
+const TYPE_CHUNK_DELAY_MS = 45;
 const TYPE_CHUNK_SIZE = 24;
 const MIRROR_SUPPRESSION_WINDOW_MS = 30 * 1000;
 const PENDING_RELAY_CONTEXT_TTL_MS = 2 * 60 * 1000;
@@ -54,10 +57,61 @@ 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";
 }
 
+function normalizeContinueSeatId(value) {
+  const seatId = normalizeSeatId(value);
+  return seatId || null;
+}
+
+function normalizeContinueTargets(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  return value
+    .map((entry) => {
+      const seatId = normalizeSeatId(entry?.seatId);
+      if (!seatId) {
+        return null;
+      }
+
+      return {
+        seatId,
+        flowMode: normalizeFlowMode(entry?.flowMode),
+      };
+    })
+    .filter((entry) => entry !== null);
+}
+
 function resolveShell() {
   const shell = String(process.env.SHELL || "").trim();
   return shell || "/bin/bash";
@@ -127,11 +181,6 @@ function createSessionName(currentPath = process.cwd()) {
   return `${getDefaultSessionName(currentPath)}-${createId(6)}`;
 }
 
-function getAnchorSeatId(seatId = 1) {
-  const normalizedSeatId = normalizeSeatId(seatId) || 1;
-  return normalizedSeatId % 2 === 0 ? normalizedSeatId - 1 : normalizedSeatId;
-}
-
 function sleepSync(ms) {
   if (!Number.isFinite(ms) || ms <= 0) {
     return;
@@ -140,33 +189,45 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
-function findExistingSessionName(currentPath = process.cwd(), anchorSeatId = null) {
-  const targetAnchorSeatId = normalizeSeatId(anchorSeatId) || null;
+function findJoinableSessionName(currentPath = process.cwd(), seatId = 2) {
+  const normalizedSeatId = normalizeSeatId(seatId);
+  const partnerSeatId = getPartnerSeatId(normalizedSeatId);
+  if (!normalizedSeatId || !partnerSeatId) {
+    return null;
+  }
+
   const candidates = listSessionNames()
     .map((sessionName) => {
       const sessionPaths = getSessionPaths(sessionName);
       const controller = readJson(sessionPaths.controllerPath, null);
-      const cwd = controller?.cwd || null;
+      const partnerPaths = getSeatPaths(sessionName, partnerSeatId);
+      const seatPaths = getSeatPaths(sessionName, normalizedSeatId);
+      const partnerMeta = readJson(partnerPaths.metaPath, null);
+      const partnerStatus = readJson(partnerPaths.statusPath, null);
+      const seatMeta = readJson(seatPaths.metaPath, null);
+      const seatStatus = readJson(seatPaths.statusPath, null);
+      const stopRequest = readJson(sessionPaths.stopPath, null);
+
+      const cwd = controller?.cwd || partnerStatus?.cwd || partnerMeta?.cwd || seatStatus?.cwd || seatMeta?.cwd || null;
       if (!matchesWorkingPath(cwd, currentPath)) {
         return null;
       }
 
-      const stopRequest = readJson(sessionPaths.stopPath, null);
+      const partnerWrapperPid = partnerStatus?.pid || partnerMeta?.pid || null;
+      const partnerChildPid = partnerStatus?.childPid || partnerMeta?.childPid || null;
+      const seatWrapperPid = seatStatus?.pid || seatMeta?.pid || null;
+      const seatChildPid = seatStatus?.childPid || seatMeta?.childPid || null;
+      const partnerLive = isPidAlive(partnerWrapperPid) || isPidAlive(partnerChildPid);
+      const seatLive = isPidAlive(seatWrapperPid) || isPidAlive(seatChildPid);
       const stopRequestedAtMs = Date.parse(stopRequest?.requestedAt || "");
-      const createdAtMs = Date.parse(controller?.createdAt || "");
+      const createdAtMs = Date.parse(controller?.createdAt || partnerMeta?.startedAt || partnerStatus?.updatedAt || "");
 
-      if (Number.isFinite(stopRequestedAtMs) && Number.isFinite(createdAtMs) && stopRequestedAtMs > createdAtMs) {
+      if (!partnerLive || seatLive) {
         return null;
       }
 
-      if (targetAnchorSeatId) {
-        const controllerAnchorSeatId = normalizeSeatId(controller?.anchorSeatId);
-        if (controllerAnchorSeatId && controllerAnchorSeatId !== targetAnchorSeatId) {
-          return null;
-        }
-        if (!controllerAnchorSeatId && !getSeatDirIfExists(sessionName, targetAnchorSeatId)) {
-          return null;
-        }
+      if (Number.isFinite(stopRequestedAtMs) && Number.isFinite(createdAtMs) && stopRequestedAtMs > createdAtMs) {
+        return null;
       }
 
       return {
@@ -180,10 +241,10 @@ function findExistingSessionName(currentPath = process.cwd(), anchorSeatId = nul
   return candidates[0]?.sessionName || null;
 }
 
-function waitForExistingSessionName(currentPath = process.cwd(), timeoutMs = SEAT_JOIN_WAIT_MS, anchorSeatId = null) {
+function waitForJoinableSessionName(currentPath = process.cwd(), seatId = 2, timeoutMs = SEAT_JOIN_WAIT_MS) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
-    const sessionName = findExistingSessionName(currentPath, anchorSeatId);
+    const sessionName = findJoinableSessionName(currentPath, seatId);
     if (sessionName) {
       return sessionName;
     }
@@ -194,17 +255,13 @@ function waitForExistingSessionName(currentPath = process.cwd(), timeoutMs = SEA
 }
 
 function resolveSessionName(currentPath = process.cwd(), seatId = 1) {
-  const anchorSeatId = getAnchorSeatId(seatId);
-  const existing = findExistingSessionName(currentPath, anchorSeatId);
-  if (existing) {
-    return existing;
+  const joinableSessionName = findJoinableSessionName(currentPath, seatId);
+  if (joinableSessionName) {
+    return joinableSessionName;
   }
 
-  if (seatId % 2 === 0) {
-    const waited = waitForExistingSessionName(currentPath, SEAT_JOIN_WAIT_MS, anchorSeatId);
-    if (waited) {
-      return waited;
-    }
+  if (!isAnchorSeat(seatId)) {
+    return waitForJoinableSessionName(currentPath, seatId) || createSessionName(currentPath);
   }
 
   return createSessionName(currentPath);
@@ -409,6 +466,26 @@ function resolveSessionFile(agentType, agentPid, currentPath, captureSinceMs, pr
   return null;
 }
 
+function buildClaimMessage(sessionName, challenge, seat1PublicKey, seat2PublicKey) {
+  return JSON.stringify({
+    type: "muuuuse_pair_claim",
+    sessionName,
+    challenge,
+    seat1PublicKey,
+    seat2PublicKey,
+  });
+}
+
+function buildAckMessage(sessionName, challenge, seat1PublicKey, seat2PublicKey) {
+  return JSON.stringify({
+    type: "muuuuse_pair_ack",
+    sessionName,
+    challenge,
+    seat1PublicKey,
+    seat2PublicKey,
+  });
+}
+
 function buildAnswerSignaturePayload(sessionName, challenge, entry) {
   return JSON.stringify({
     type: "muuuuse_answer",
@@ -421,17 +498,20 @@ function buildAnswerSignaturePayload(sessionName, challenge, entry) {
     origin: entry.origin,
     phase: entry.phase || "final_answer",
     createdAt: entry.createdAt,
+    targetSeatId: entry.targetSeatId || null,
+    targetFlowMode: normalizeFlowMode(entry.targetFlowMode),
     text: entry.text,
   });
 }
 
-function buildContinuationEntry(sourceSessionName, targetSeatId, entry) {
+function buildContinuationEntry(sourceSessionName, targetSeatId, entry, targetFlowMode = null) {
   return {
     id: createId(12),
     type: "continue",
     sourceSessionName,
     sourceSeatId: entry.seatId,
     targetSeatId,
+    targetFlowMode: normalizeFlowMode(targetFlowMode),
     origin: entry.origin || "unknown",
     phase: entry.phase || "final_answer",
     text: entry.text,
@@ -453,6 +533,15 @@ function shouldAcceptInboundEntry(flowMode, entry) {
   return flowMode === "on" || getRelayPhase(entry) === "final_answer";
 }
 
+function resolveInboundFlowMode(defaultFlowMode, seatId, entry) {
+  const targetSeatId = normalizeSeatId(entry?.targetSeatId);
+  if (targetSeatId === normalizeSeatId(seatId)) {
+    return normalizeFlowMode(entry?.targetFlowMode);
+  }
+
+  return normalizeFlowMode(defaultFlowMode);
+}
+
 function getSeatDirIfExists(sessionName, seatId) {
   const dir = path.join(getStateRoot(), "sessions", sessionName, `seat-${seatId}`);
   try {
@@ -548,7 +637,7 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
   }
 
   try {
-    child.write("\n");
+    child.write("\r");
   } catch {
     return false;
   }
@@ -559,52 +648,29 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
 class ArmedSeat {
   constructor(options) {
     this.seatId = options.seatId;
-    this.anchorSeatId = getAnchorSeatId(this.seatId);
-    this.partnerSeatId = this.seatId % 2 === 0 ? this.seatId - 1 : this.seatId + 1;
-    this.continueTargets = Array.isArray(options.continueTargets) ? options.continueTargets : [];
+    this.partnerSeatId = getPartnerSeatId(options.seatId);
+    this.anchorSeatId = isAnchorSeat(options.seatId) ? options.seatId : this.partnerSeatId;
+    this.flowMode = normalizeFlowMode(options.flowMode);
+    this.continueSeatId = normalizeContinueSeatId(options.continueSeatId);
+    this.continueTargets = normalizeContinueTargets(options.continueTargets);
     this.cwd = normalizeWorkingPath(options.cwd);
-
-    // Auto-link adjacent partner seat for backwards compatibility (1↔2, 3↔4, ...).
-    if (this.continueTargets.length === 0) {
-      if (this.partnerSeatId > 0) {
-        this.continueTargets.push({ targetSeatId: this.partnerSeatId, flowMode: "on" });
-      }
+    if (this.continueSeatId === this.seatId) {
+      throw new Error(`\`muuuuse ${this.seatId}\` cannot continue to itself.`);
     }
-
-    if (this.continueTargets.some((t) => t.targetSeatId === this.seatId)) {
-      throw new Error(`\`muuuuse ${this.seatId}\` cannot relay to itself.`);
+    if (this.continueTargets.some((target) => target.seatId === this.seatId)) {
+      throw new Error(`\`muuuuse ${this.seatId}\` cannot link to itself.`);
     }
     this.sessionName = resolveSessionName(this.cwd, this.seatId);
     if (!this.sessionName) {
       throw new Error(
-        `Failed to create or find session in ${this.cwd}.`
+        `No armed \`muuuuse ${this.partnerSeatId}\` seat is waiting in this cwd. Run \`muuuuse ${this.partnerSeatId}\` first.`
       );
     }
     this.sessionPaths = getSessionPaths(this.sessionName);
     this.paths = getSeatPaths(this.sessionName, this.seatId);
+    this.partnerPaths = getSeatPaths(this.sessionName, this.partnerSeatId);
     this.continueOffset = getFileSize(this.paths.continuePath);
-
-    // Per-target trust state, paths, and event offsets for the signed relay channel.
-    // Only create directories for same-session targets (same anchor pair).
-    // Cross-session targets use the continuation channel and don't need local seat dirs.
-    const ownAnchor = getAnchorSeatId(this.seatId);
-    this.targetTrust = {};
-    this.targetPaths = {};
-    this.targetOffsets = {};
-    for (const t of this.continueTargets) {
-      const sameSession = getAnchorSeatId(t.targetSeatId) === ownAnchor;
-      this.targetTrust[t.targetSeatId] = {
-        challenge: null,
-        peerPublicKey: null,
-        phase: "initializing",
-        pairedAt: null,
-        sameSession,
-      };
-      this.targetPaths[t.targetSeatId] = sameSession
-        ? getSeatPaths(this.sessionName, t.targetSeatId)
-        : null;
-      this.targetOffsets[t.targetSeatId] = 0;
-    }
+    this.partnerOffset = getFileSize(this.partnerPaths.eventsPath);
 
     this.child = null;
     this.childPid = null;
@@ -618,11 +684,16 @@ class ArmedSeat {
     this.resizeCleanup = null;
     this.forceKillTimer = null;
     this.identity = null;
-    this.ownChallenge = null;
     this.lastUserInputAtMs = 0;
     this.pendingInboundContext = null;
     this.recentInboundRelays = [];
     this.recentEmittedAnswers = [];
+    this.trustState = {
+      challenge: null,
+      peerPublicKey: null,
+      phase: isAnchorSeat(this.seatId) ? "waiting_for_peer_signature" : "waiting_for_anchor_key",
+      pairedAt: null,
+    };
     this.liveState = {
       type: null,
       pid: null,
@@ -645,6 +716,9 @@ class ArmedSeat {
       updatedAt: new Date().toISOString(),
       anchorSeatId: this.anchorSeatId,
       partnerSeatId: this.partnerSeatId,
+      anchorSeatPid: this.seatId === this.anchorSeatId ? process.pid : current.anchorSeatPid || null,
+      partnerSeatPid: this.seatId === this.partnerSeatId ? process.pid : current.partnerSeatPid || null,
+      pid: this.seatId === this.anchorSeatId ? process.pid : current.pid || null,
       ...extra,
     });
   }
@@ -656,7 +730,10 @@ class ArmedSeat {
   writeMeta(extra = {}) {
     writeJson(this.paths.metaPath, {
       seatId: this.seatId,
+      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
+      flowMode: this.flowMode,
+      continueSeatId: this.continueSeatId,
       continueTargets: this.continueTargets,
       cwd: this.cwd,
       pid: process.pid,
@@ -670,7 +747,10 @@ class ArmedSeat {
   writeStatus(extra = {}) {
     writeJson(this.paths.statusPath, {
       seatId: this.seatId,
+      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
+      flowMode: this.flowMode,
+      continueSeatId: this.continueSeatId,
       continueTargets: this.continueTargets,
       cwd: this.cwd,
       pid: process.pid,
@@ -683,84 +763,168 @@ class ArmedSeat {
 
   initializeTrustMaterial() {
     this.identity = loadOrCreateSeatIdentity(this.paths);
-    const ownChallenge = createId(48);
+
+    if (!isAnchorSeat(this.seatId)) {
+      return;
+    }
+
     writeJson(this.paths.challengePath, {
       sessionName: this.sessionName,
-      challenge: ownChallenge,
+      challenge: createId(48),
       publicKey: this.identity.publicKey,
       createdAt: new Date().toISOString(),
     });
-    this.ownChallenge = ownChallenge;
+    this.trustState.challenge = readSeatChallenge(this.paths, this.sessionName)?.challenge || null;
+    this.trustState.peerPublicKey = null;
+    this.trustState.phase = "waiting_for_peer_signature";
+    this.trustState.pairedAt = null;
+    fs.rmSync(this.paths.ackPath, { force: true });
+    fs.rmSync(this.partnerPaths.claimPath, { force: true });
   }
 
-  syncTargetTrust() {
+  syncTrustState() {
     if (!this.identity) {
       this.initializeTrustMaterial();
     }
 
-    for (const target of this.continueTargets) {
-      this.syncOneTargetTrust(target.targetSeatId);
+    if (isAnchorSeat(this.seatId)) {
+      this.syncSeatOneTrust();
+      return;
     }
+
+    this.syncSeatTwoTrust();
   }
 
-  syncOneTargetTrust(targetSeatId) {
-    const trust = this.targetTrust[targetSeatId];
-    if (!trust || trust.phase === "paired") {
+  syncSeatOneTrust() {
+    const challengeRecord = readSeatChallenge(this.paths, this.sessionName);
+    if (!challengeRecord || challengeRecord.publicKey !== this.identity.publicKey) {
+      this.trustState = {
+        challenge: null,
+        peerPublicKey: null,
+        phase: "waiting_for_peer_signature",
+        pairedAt: null,
+      };
       return;
     }
 
-    // Cross-session target: relay goes through the continuation channel only.
-    if (!trust.sameSession) {
-      trust.phase = "paired";
-      trust.pairedAt = new Date().toISOString();
+    this.trustState.challenge = challengeRecord.challenge;
+    const claim = readJson(this.partnerPaths.claimPath, null);
+    if (
+      !claim ||
+      claim.sessionName !== this.sessionName ||
+      claim.challenge !== challengeRecord.challenge ||
+      typeof claim.publicKey !== "string" ||
+      typeof claim.signature !== "string" ||
+      !verifyText(
+        buildClaimMessage(
+          this.sessionName,
+          challengeRecord.challenge,
+          this.identity.publicKey,
+          claim.publicKey.trim()
+        ),
+        claim.signature,
+        claim.publicKey
+      )
+    ) {
+      this.trustState.peerPublicKey = null;
+      this.trustState.phase = "waiting_for_peer_signature";
+      this.trustState.pairedAt = null;
+      fs.rmSync(this.paths.ackPath, { force: true });
       return;
     }
 
-    // Same-session target: read their challenge.json to get their public key
-    // and challenge. One-way trust — we just need to verify their events.
-    const targetPaths = this.targetPaths[targetSeatId];
-    if (!targetPaths) {
-      return;
+    const peerPublicKey = claim.publicKey.trim();
+    const ackMessage = buildAckMessage(this.sessionName, challengeRecord.challenge, this.identity.publicKey, peerPublicKey);
+    const currentAck = readJson(this.paths.ackPath, null);
+    const ackIsValid = Boolean(
+      currentAck &&
+      currentAck.sessionName === this.sessionName &&
+      currentAck.challenge === challengeRecord.challenge &&
+      currentAck.publicKey === this.identity.publicKey &&
+      currentAck.peerPublicKey === peerPublicKey &&
+      typeof currentAck.signature === "string" &&
+      verifyText(ackMessage, currentAck.signature, this.identity.publicKey)
+    );
+    if (!ackIsValid) {
+      writeJson(this.paths.ackPath, {
+        sessionName: this.sessionName,
+        challenge: challengeRecord.challenge,
+        publicKey: this.identity.publicKey,
+        peerPublicKey,
+        signature: signText(ackMessage, this.identity.privateKey),
+        signedAt: new Date().toISOString(),
+      });
     }
 
-    const targetChallenge = readSeatChallenge(targetPaths, this.sessionName);
-    if (!targetChallenge) {
-      trust.phase = "waiting_for_target";
+    const ackRecord = ackIsValid ? currentAck : readJson(this.paths.ackPath, null);
+    this.trustState.peerPublicKey = peerPublicKey;
+    this.trustState.phase = "paired";
+    this.trustState.pairedAt = ackRecord?.signedAt || new Date().toISOString();
+  }
+
+  syncSeatTwoTrust() {
+    const challengeRecord = readSeatChallenge(this.partnerPaths, this.sessionName);
+    if (!challengeRecord) {
+      this.trustState = {
+        challenge: null,
+        peerPublicKey: null,
+        phase: "waiting_for_anchor_key",
+        pairedAt: null,
+      };
       return;
     }
 
-    trust.challenge = targetChallenge.challenge;
-    trust.peerPublicKey = targetChallenge.publicKey;
-    trust.phase = "paired";
-    trust.pairedAt = new Date().toISOString();
+    const challenge = challengeRecord.challenge;
+    const peerPublicKey = challengeRecord.publicKey;
+    const claimPayload = {
+      sessionName: this.sessionName,
+      challenge,
+      publicKey: this.identity.publicKey,
+    };
+    const claimSignature = signText(
+      buildClaimMessage(this.sessionName, challenge, peerPublicKey, this.identity.publicKey),
+      this.identity.privateKey
+    );
+    const currentClaim = readJson(this.paths.claimPath, null);
+    if (
+      !currentClaim ||
+      currentClaim.sessionName !== claimPayload.sessionName ||
+      currentClaim.challenge !== claimPayload.challenge ||
+      currentClaim.publicKey !== claimPayload.publicKey ||
+      currentClaim.signature !== claimSignature
+    ) {
+      writeJson(this.paths.claimPath, {
+        ...claimPayload,
+        signature: claimSignature,
+        signedAt: new Date().toISOString(),
+      });
+    }
 
-    // Initialize offset to current file size so we only read new events.
-    this.targetOffsets[targetSeatId] = getFileSize(targetPaths.eventsPath);
-  }
+    const ack = readJson(this.partnerPaths.ackPath, null);
+    const paired = Boolean(
+      ack &&
+      ack.sessionName === this.sessionName &&
+      ack.challenge === challenge &&
+      ack.peerPublicKey === this.identity.publicKey &&
+      ack.publicKey === peerPublicKey &&
+      typeof ack.signature === "string" &&
+      verifyText(
+        buildAckMessage(this.sessionName, challenge, peerPublicKey, this.identity.publicKey),
+        ack.signature,
+        peerPublicKey
+      )
+    );
 
-  isTargetPaired(targetSeatId) {
-    const trust = this.targetTrust[targetSeatId];
-    return Boolean(trust && trust.phase === "paired");
+    this.trustState.challenge = challenge;
+    this.trustState.peerPublicKey = peerPublicKey;
+    this.trustState.phase = paired ? "paired" : "waiting_for_pair_ack";
+    this.trustState.pairedAt = paired ? (ack.signedAt || new Date().toISOString()) : null;
   }
 
-  getOverallTrustPhase() {
-    const targets = this.continueTargets;
-    if (targets.length === 0) {
-      return "paired";
-    }
-    const allPaired = targets.every((t) => this.isTargetPaired(t.targetSeatId));
-    if (allPaired) {
-      return "paired";
-    }
-    const anyPaired = targets.some((t) => this.isTargetPaired(t.targetSeatId));
-    if (anyPaired) {
-      return "partial";
-    }
-    return "initializing";
-  }
-
-  hasAnyPairedTarget() {
-    return this.continueTargets.some((t) => this.isTargetPaired(t.targetSeatId));
+  isPaired() {
+    return this.trustState.phase === "paired" &&
+      typeof this.trustState.challenge === "string" &&
+      typeof this.trustState.peerPublicKey === "string";
   }
 
   launchShell() {
@@ -768,7 +932,6 @@ class ArmedSeat {
     fs.rmSync(this.paths.pipePath, { force: true });
     clearStaleStopRequest(this.sessionPaths.stopPath, this.startedAtMs);
     this.initializeTrustMaterial();
-    this.syncTargetTrust();
     this.writeController();
 
     const shell = resolveShell();
@@ -781,10 +944,11 @@ class ArmedSeat {
       env: childEnv,
       name: childEnv.TERM,
     });
+    bestEffortEnableChildEcho(this.child);
 
     this.childPid = this.child.pid;
     this.writeMeta();
-    this.writeStatus({ state: "running", trust: this.getOverallTrustPhase() });
+    this.writeStatus({ state: "running", trust: this.trustState.phase });
 
     this.child.onData((data) => {
       fs.appendFileSync(this.paths.pipePath, data);
@@ -918,6 +1082,32 @@ class ArmedSeat {
     }
   }
 
+  partnerIsLive() {
+    const partner = readJson(this.partnerPaths.statusPath, null);
+    return Boolean(partner?.pid && isPidAlive(partner.pid));
+  }
+
+  getLinkTarget(seatId) {
+    const desiredSeatId = normalizeContinueSeatId(seatId);
+    if (!desiredSeatId) {
+      return null;
+    }
+
+    return this.continueTargets.find((target) => target.seatId === desiredSeatId) || null;
+  }
+
+  getPartnerLinkTarget() {
+    return this.getLinkTarget(this.partnerSeatId);
+  }
+
+  shouldCaptureCommentary() {
+    if (this.flowMode === "on") {
+      return true;
+    }
+
+    return this.continueTargets.some((target) => target.flowMode === "on");
+  }
+
   stopRequested() {
     const request = readJson(this.sessionPaths.stopPath, null);
     if (!request?.requestedAt) {
@@ -929,18 +1119,18 @@ class ArmedSeat {
   }
 
   findContinuationTarget(targetSeatId = null) {
-    const seatIdToFind = targetSeatId || this.continueSeatId;
-    if (!seatIdToFind) {
+    const desiredSeatId = normalizeContinueSeatId(targetSeatId);
+    if (!desiredSeatId) {
       return null;
     }
 
     const candidates = listSessionNames()
       .map((sessionName) => {
-        if (!getSeatDirIfExists(sessionName, seatIdToFind)) {
+        if (!getSeatDirIfExists(sessionName, desiredSeatId)) {
           return null;
         }
 
-        const seat = buildSeatReport(sessionName, seatIdToFind);
+        const seat = buildSeatReport(sessionName, desiredSeatId);
         if (!seat || !matchesWorkingPath(seat.cwd, this.cwd)) {
           return null;
         }
@@ -967,6 +1157,73 @@ class ArmedSeat {
     };
   }
 
+  async pullPartnerEvents() {
+    const { nextOffset, text } = readAppendedText(this.partnerPaths.eventsPath, this.partnerOffset);
+    this.partnerOffset = nextOffset;
+    if (!text.trim() || !this.child || this.stopped || !this.isPaired()) {
+      return;
+    }
+
+    const entries = parseAnswerEntries(text);
+    for (const entry of entries) {
+      if (this.stopped || this.stopRequested()) {
+        this.requestStop("stop_requested");
+        return;
+      }
+
+      if (!shouldAcceptInboundEntry(resolveInboundFlowMode(this.flowMode, this.seatId, entry), entry)) {
+        continue;
+      }
+
+      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",
+        phase: getRelayPhase(entry),
+        createdAt: entry.createdAt,
+        text: payload,
+      });
+      if (
+        !payload ||
+        entry.challenge !== this.trustState.challenge ||
+        entry.publicKey !== this.trustState.peerPublicKey ||
+        typeof entry.signature !== "string" ||
+        !verifyText(signaturePayload, entry.signature, this.trustState.peerPublicKey)
+      ) {
+        continue;
+      }
+
+      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;
+      }
+
+      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,
+      };
+      this.relayCount += 1;
+      this.rememberInboundRelay(payload);
+      this.log(`[${this.partnerSeatId} -> ${this.seatId}] ${previewText(payload)}`);
+    }
+  }
+
   async pullContinuationEvents() {
     const { nextOffset, text } = readAppendedText(this.paths.continuePath, this.continueOffset);
     this.continueOffset = nextOffset;
@@ -981,6 +1238,10 @@ class ArmedSeat {
         return;
       }
 
+      if (!shouldAcceptInboundEntry(resolveInboundFlowMode(this.flowMode, this.seatId, entry), entry)) {
+        continue;
+      }
+
       const payload = sanitizeRelayText(entry.text);
       if (!payload) {
         continue;
@@ -1194,7 +1455,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: true }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1203,7 +1464,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: true }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1212,7 +1473,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.lastMessageId,
         this.liveState.captureSinceMs,
-        { flowMode: true }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.lastMessageId = result.lastMessageId;
       this.liveState.offset = result.fileSize;
@@ -1245,11 +1506,7 @@ class ArmedSeat {
     }
 
     const payload = sanitizeRelayText(entry.text);
-    if (!payload || !this.identity || !this.ownChallenge) {
-      return;
-    }
-
-    if (!this.hasAnyPairedTarget()) {
+    if (!payload) {
       return;
     }
 
@@ -1266,11 +1523,9 @@ class ArmedSeat {
     }
 
     const pendingInboundContext = this.getPendingInboundContext();
-    const entryId = entry.id || createId(12);
 
-    // Sign with OUR OWN challenge. Each reader verifies using our challenge
-    // (which they obtained during the trust handshake as peerChallenge).
-    const signedEntry = {
+    const entryId = entry.id || createId(12);
+    const relayEntry = {
       id: entryId,
       type: "answer",
       seatId: this.seatId,
@@ -1280,67 +1535,85 @@ class ArmedSeat {
       createdAt: entry.createdAt || new Date().toISOString(),
       chainId: pendingInboundContext?.chainId || entry.chainId || entryId,
       hop: pendingInboundContext ? pendingInboundContext.hop + 1 : 0,
-      challenge: this.ownChallenge,
-      publicKey: this.identity.publicKey,
     };
-    signedEntry.signature = signText(
-      buildAnswerSignaturePayload(this.sessionName, this.ownChallenge, signedEntry),
-      this.identity.privateKey
-    );
-    appendJsonl(this.paths.eventsPath, signedEntry);
 
-    // Forward via continuation channel for cross-session targets.
-    for (const target of this.continueTargets) {
-      this.forwardContinuation(signedEntry, target);
+    const partnerLinkTarget = this.getPartnerLinkTarget();
+    let outboundEntry = relayEntry;
+    if (this.isPaired() && this.identity) {
+      const signedEntry = {
+        ...relayEntry,
+        challenge: this.trustState.challenge,
+        publicKey: this.identity.publicKey,
+        targetSeatId: partnerLinkTarget?.seatId || null,
+        targetFlowMode: partnerLinkTarget?.flowMode || null,
+      };
+      signedEntry.signature = signText(
+        buildAnswerSignaturePayload(this.sessionName, this.trustState.challenge, signedEntry),
+        this.identity.privateKey
+      );
+
+      if (!partnerLinkTarget) {
+        appendJsonl(this.paths.eventsPath, signedEntry);
+      }
+      outboundEntry = signedEntry;
     }
 
+    if (this.continueSeatId || this.continueTargets.length > 0) {
+      this.forwardContinuation(outboundEntry);
+    }
     this.rememberEmittedAnswer(answerKey);
+
     this.log(`[${this.seatId}] ${previewText(payload)}`);
   }
 
-  forwardContinuation(signedEntry, targetEntry) {
-    if (!shouldAcceptInboundEntry(targetEntry.flowMode, signedEntry)) {
-      return;
+  forwardContinuation(signedEntry) {
+    const targets = [...this.continueTargets];
+    if (this.continueSeatId && !targets.some((target) => target.seatId === this.continueSeatId)) {
+      targets.push({
+        seatId: this.continueSeatId,
+        flowMode: null,
+      });
     }
 
-    // Same-session target: write directly to their continuation channel.
-    const trust = this.targetTrust[targetEntry.targetSeatId];
-    if (trust && trust.sameSession) {
-      const targetPaths = this.targetPaths[targetEntry.targetSeatId];
-      if (targetPaths) {
-        const continuationEntry = buildContinuationEntry(this.sessionName, targetEntry.targetSeatId, signedEntry);
-        appendJsonl(targetPaths.continuePath, continuationEntry);
-        this.log(`[${this.seatId} => ${targetEntry.targetSeatId} (${targetEntry.flowMode})] ${previewText(continuationEntry.text)}`);
-      }
+    if (targets.length === 0) {
       return;
     }
 
-    // Cross-session target: find the target across sessions.
-    const target = this.findContinuationTarget(targetEntry.targetSeatId);
-    if (!target) {
-      return;
-    }
+    for (const targetEntry of targets) {
+      if (targetEntry.flowMode && !shouldAcceptInboundEntry(targetEntry.flowMode, signedEntry)) {
+        continue;
+      }
+
+      const target = this.findContinuationTarget(targetEntry.seatId);
+      if (!target) {
+        this.log(`[${this.seatId}] continue ${targetEntry.seatId} unavailable`);
+        continue;
+      }
 
-    const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, signedEntry);
-    appendJsonl(target.paths.continuePath, continuationEntry);
-    this.log(`[${this.seatId} => ${target.seatId} (${targetEntry.flowMode})] ${previewText(continuationEntry.text)}`);
+      const continuationEntry = buildContinuationEntry(
+        this.sessionName,
+        target.seatId,
+        signedEntry,
+        targetEntry.flowMode
+      );
+      appendJsonl(target.paths.continuePath, continuationEntry);
+      this.log(`[${this.seatId} => ${target.seatId}] ${previewText(continuationEntry.text)}`);
+    }
   }
 
   async tick() {
     if (this.stopRequested()) {
       this.writeStatus({
         state: "stopping",
-        trust: this.getOverallTrustPhase(),
+        partnerLive: this.partnerIsLive(),
+        trust: this.trustState.phase,
       });
       this.requestStop("stop_requested");
       return;
     }
 
-    this.syncTargetTrust();
-    if (this.stopped || this.stopRequested()) {
-      this.requestStop("stop_requested");
-      return;
-    }
+    this.syncTrustState();
+    await this.pullPartnerEvents();
     await this.pullContinuationEvents();
     if (this.stopped || this.stopRequested()) {
       this.requestStop("stop_requested");
@@ -1355,11 +1628,13 @@ class ArmedSeat {
     this.writeStatus({
       state: live.state,
       agent: live.agent,
+      flowMode: this.flowMode,
       cwd: live.cwd,
       log: live.log,
       lastAnswerAt: live.lastAnswerAt,
-      trust: this.getOverallTrustPhase(),
-      challengeReady: this.hasAnyPairedTarget(),
+      partnerLive: this.partnerIsLive(),
+      trust: this.trustState.phase,
+      challengeReady: Boolean(this.trustState.challenge),
     });
   }
 
@@ -1371,9 +1646,23 @@ 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) {
-      const targets = this.continueTargets.map((t) => `${t.targetSeatId} (flow ${t.flowMode})`).join(", ");
-      this.log(`Seat ${this.seatId} relays to ${targets}. Establishing trust.`);
+      this.log(
+        `Seat ${this.seatId} links additional targets: ${this.continueTargets.map((target) => `${target.seatId}:${target.flowMode}`).join(", ")}.`
+      );
+    }
+    if (this.partnerIsLive()) {
+      if (isAnchorSeat(this.seatId)) {
+        this.log(`Seat ${this.seatId} generated the session key and is waiting for seat ${this.partnerSeatId} to sign it.`);
+      } else {
+        this.log(`Seat ${this.seatId} will sign the session key from seat ${this.partnerSeatId}, then relay goes live.`);
+      }
+    } else {
+      this.log(`Seat ${this.seatId} is armed without a live pair partner. Link targets can relay immediately; direct pair relay activates after seat ${this.partnerSeatId} joins.`);
     }
     this.log("Run `muuuuse status` or `muuuuse stop` from any terminal.");
 
@@ -1470,7 +1759,9 @@ function buildSeatReport(sessionName, seatId) {
   return {
     seatId,
     state: wrapperLive ? status?.state || "running" : "orphaned_child",
-    continueTargets: status?.continueTargets || meta?.continueTargets || [],
+    flowMode: status?.flowMode || meta?.flowMode || "off",
+    continueSeatId: status?.continueSeatId || meta?.continueSeatId || null,
+    continueTargets: normalizeContinueTargets(status?.continueTargets || meta?.continueTargets),
     wrapperPid,
     childPid,
     wrapperLive,
@@ -1484,6 +1775,7 @@ function buildSeatReport(sessionName, seatId) {
     trust: status?.trust || null,
     updatedAt: status?.updatedAt || null,
     lastAnswerAt: status?.lastAnswerAt || null,
+    partnerLive: Boolean(status?.partnerLive),
   };
 }
 

package/src/util.js

@@ -9,7 +9,7 @@ const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
 
-const BRAND = "🔌Muuuuse v7.0.1";
+const BRAND = "🔌Muuuuse";
 const POLL_MS = 220;
 const MAX_RELAY_CHARS = 4000;
 const SESSION_MATCH_WINDOW_MS = 5 * 60 * 1000;
@@ -175,6 +175,17 @@ function normalizeSeatId(value) {
   return seatId;
 }
 
+function isAnchorSeat(seatId) {
+  return normalizeSeatId(seatId) % 2 === 1;
+}
+
+function getPartnerSeatId(seatId) {
+  const normalized = normalizeSeatId(seatId);
+  if (!normalized) {
+    return null;
+  }
+  return isAnchorSeat(normalized) ? normalized + 1 : normalized - 1;
+}
 
 function listSeatIds(sessionName) {
   const sessionDir = getSessionDir(sessionName);
@@ -271,28 +282,39 @@ function listSessionNames() {
 
 function usage() {
   return [
-    `${BRAND} relay protocol for long-horizon zero-drift agentic code loops. agents relay output between terminals, converging to lucid conclusions.`,
+    `${BRAND} arms regular terminals and relays assistant output across odd/even partners plus explicit links.`,
     "",
     "Usage:",
     "  muuuuse 1",
-    "  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 1 link 2 flow on 3 flow off 5 flow off",
     "  muuuuse 2",
-    "  muuuuse 2 link 3 flow on",
+    "  muuuuse 2 flow on",
+    "  muuuuse 2 flow off",
+    "  muuuuse 2 flow on continue 3",
+    "  muuuuse 2 link 3 flow off",
     "  muuuuse 3",
+    "  muuuuse 4",
+    "  muuuuse 4 flow on continue 1",
     "  muuuuse stop",
     "  muuuuse status",
     "",
     "Flow:",
-    "  1. Run `muuuuse <seat>` in each terminal to arm it (any seat number, any count).",
-    "  2. Optionally add `link <target> flow on/off [<target> flow on/off ...]` to relay output to other seats.",
-    "  3. Use those armed shells normally. Codex, Claude, and Gemini relay automatically from their local session logs.",
-    "  4. `flow off` sends final answers only. `flow on` sends both commentary and final answers.",
-    "  5. Run `muuuuse status` or `muuuuse stop` from any terminal.",
+    "  1. Run `muuuuse <seat>` in the terminal you want to arm.",
+    "  2. Matching odd/even partners still auto-pair when both seats are armed, in either order.",
+    "  3. Additional pairs work the same way: `3/4`, `5/6`, `7/8`...",
+    "  4. Optional: arm each seat with `flow on` or `flow off`.",
+    "  5. Optional: add `continue <seat>` to forward that seat's relayed output into another armed seat.",
+    "  6. Or use `link <seat> flow on|off ...` to fan out to multiple armed seats.",
+    "  7. Standalone seats can still route through links even before a pair partner joins.",
+    "  8. Use those armed shells normally.",
+    "  9. `flow off` sends final answers only. `flow on` keeps assistant commentary bouncing.",
+    "  10. Run `muuuuse status` or `muuuuse stop` from any shell.",
     "",
     "Notes:",
-    "  - Any seat can relay to any other seat independently.",
-    "  - `muuuuse stop` and `muuuuse status` work from any terminal.",
+    "  - `muuuuse stop` and `muuuuse status` work from another terminal or the same one.",
     "  - State lives under `~/.muuuuse`.",
   ].join("\n");
 }
@@ -306,7 +328,9 @@ module.exports = {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
+  getPartnerSeatId,
   loadOrCreateSeatIdentity,
+  isAnchorSeat,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,