muuuuse 2.3.6 → 3.3.1

package/README.md

@@ -5,11 +5,10 @@
 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
-- additional isolated pairs work the same way: `3/4`, `5/6`, `7/8`, ...
+- let each seat define signed relay links to any other armed seat
 - 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
+- inject that output into linked armed terminals
 - keep looping until you stop it
 
 The whole surface is:
@@ -19,9 +18,11 @@ muuuuse 1
 muuuuse 1 flow on
 muuuuse 1 flow off
 muuuuse 1 flow off continue 5
+muuuuse 1 link 2 flow on 3 flow off 5 flow off
 muuuuse 2
 muuuuse 2 flow off
 muuuuse 2 flow on continue 3
+muuuuse 2 link 1 flow off 3 flow on 4 flow on
 muuuuse 3
 muuuuse 3 flow on
 muuuuse 4
@@ -35,20 +36,20 @@ muuuuse stop
 Terminal 1:
 
 ```bash
-muuuuse 1 flow on
+muuuuse 1 link 2 flow on
 ```
 
 Terminal 2:
 
 ```bash
-muuuuse 2 flow off
+muuuuse 2 link 1 flow off link 3 flow on link 4 flow on
 ```
 
-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.
+Now both shells are armed in the same cwd and join the same relay graph. Every seat has its own Ed25519 keypair. Each forwarded relay is signed by the sending seat. A target seat only accepts inbound relays from seats it links back to, so the graph can be open-ended without becoming an all-to-all broadcast.
 
-`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.
+`link <seat> flow on` means that outbound edge sends commentary and final answers. `link <seat> flow off` means that outbound edge sends final answers only. This is sender-side routing, not receiver-side filtering.
 
-`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.
+`continue <seat>` is shorthand for one outbound link that uses the seat's default `flow on|off`. Explicit `link ... flow ...` edges are the full model and can be arranged into loops such as `1 -> 2 -> 3 -> 4 -> 1`.
 
 If you want Codex in one and Gemini in the other, start them inside the armed shells:
 
@@ -60,7 +61,7 @@ codex
 gemini
 ```
 
-`🔌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.
+`🔌Muuuuse` tails the local session logs for supported CLIs, relays according to each outbound link's flow mode, types that output into the target seat, and then sends Enter as a separate keystroke.
 
 Check the live state from any terminal:
 
@@ -77,8 +78,9 @@ muuuuse stop
 ## Notes
 
 - state lives under `~/.muuuuse`
-- only the signed armed pair can exchange relay events
-- `continue <seat>` is a separate local forwarding lane and can target any armed seat number
+- all armed seats in the same cwd share one relay session graph
+- only signed relays from reciprocally linked seats are accepted
+- `continue <seat>` is a convenience alias for a single signed outbound link
 - supported relay detection is built for Codex, Claude, and Gemini
 
 ## Install

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "2.3.6",
-  "description": "🔌Muuuuse arms regular terminals in isolated pairs and can continue relay output into any other armed seat.",
+  "version": "3.3.1",
+  "description": "🔌Muuuuse arms regular terminals and relays assistant output across signed terminal links.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"

package/src/cli.js

@@ -56,10 +56,11 @@ async function main(argv = process.argv.slice(2)) {
 
   const seatId = normalizeSeatId(command);
   if (seatId) {
-    const { flowMode, continueSeatId } = 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,
     });
@@ -80,14 +81,11 @@ function renderSeatStatus(seat) {
     `child ${seat.childPid || "-"}`,
   ];
 
-  if (seat.partnerLive) {
-    bits.push("peer live");
-  }
   if (seat.continueSeatId) {
     bits.push(`continue ${seat.continueSeatId}`);
   }
-  if (seat.trust) {
-    bits.push(`trust ${seat.trust}`);
+  if (Array.isArray(seat.continueTargets) && seat.continueTargets.length > 0) {
+    bits.push(`links ${renderLinkTargets(seat.continueTargets)}`);
   }
   if (seat.lastAnswerAt) {
     bits.push(`last answer ${seat.lastAnswerAt}`);
@@ -103,17 +101,26 @@ function renderSeatStatus(seat) {
   return output;
 }
 
+function renderLinkTargets(targets) {
+  return targets
+    .map((target) => `${target.seatId}:${target.flowMode}`)
+    .join(", ");
+}
+
 function parseSeatOptions(command, args) {
+  const seatId = normalizeSeatId(command);
   let flowMode = "off";
   let continueSeatId = null;
+  let continueTargets = [];
+  let index = 0;
 
-  for (let index = 0; index < args.length;) {
+  for (; 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;
+      const nextFlowMode = parseFlowModeToken(args[index + 1]);
+      if (nextFlowMode) {
+        flowMode = nextFlowMode;
         index += 2;
         continue;
       }
@@ -122,7 +129,7 @@ function parseSeatOptions(command, args) {
 
     if (token === "continue") {
       const targetSeatId = normalizeSeatId(args[index + 1]);
-      if (targetSeatId) {
+      if (targetSeatId && targetSeatId !== seatId) {
         continueSeatId = targetSeatId;
         index += 2;
         continue;
@@ -130,28 +137,94 @@ function parseSeatOptions(command, args) {
       break;
     }
 
+    if (token === "link") {
+      const parsed = parseLinkTargets(seatId, args, index + 1);
+      if (!parsed) {
+        break;
+      }
+
+      continueTargets = mergeTargets(continueTargets, parsed.continueTargets);
+      index = parsed.nextIndex;
+      continue;
+    }
+
     break;
   }
 
-  if (args.length === 0 || (flowMode || continueSeatId !== null) && consumedAllArgs(args, flowMode, continueSeatId)) {
-    return { flowMode, continueSeatId };
+  if (index === args.length) {
+    return { flowMode, continueSeatId, continueTargets };
   }
 
   throw new Error(
-    `\`muuuuse ${command}\` accepts no extra arguments, \`flow on\` / \`flow off\`, optional \`continue <seat>\`, or both in sequence. 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 consumedAllArgs(args, flowMode, continueSeatId) {
-  const expected = [];
-  if (flowMode !== "off" || args.includes("flow")) {
-    expected.push("flow", flowMode);
+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(seatId, args, startIndex) {
+  let index = startIndex;
+  const continueTargets = [];
+
+  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[index + 2]);
+    if (!targetFlowMode) {
+      break;
+    }
+
+    upsertTarget(continueTargets, {
+      seatId: targetSeatId,
+      flowMode: targetFlowMode,
+    });
+
+    index += 3;
+  }
+
+  if (index === startIndex) {
+    return null;
+  }
+
+  return {
+    continueTargets,
+    nextIndex: index,
+  };
+}
+
+function parseFlowModeToken(value) {
+  const token = String(value || "").trim().toLowerCase();
+  if (token === "on" || token === "off") {
+    return token;
   }
-  if (continueSeatId !== null || args.includes("continue")) {
-    expected.push("continue", String(continueSeatId));
+  return null;
+}
+
+function upsertTarget(targets, nextTarget) {
+  const currentIndex = targets.findIndex((target) => target.seatId === nextTarget.seatId);
+  if (currentIndex === -1) {
+    targets.push(nextTarget);
+    return;
   }
-  return expected.length === args.length &&
-    expected.every((value, index) => String(args[index]).trim().toLowerCase() === String(value).trim().toLowerCase());
+
+  targets[currentIndex] = nextTarget;
 }
 
 module.exports = {

package/src/runtime.js

@@ -20,12 +20,10 @@ const {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
-  getPartnerSeatId,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,
   hashText,
-  isAnchorSeat,
   isPidAlive,
   listSeatIds,
   loadOrCreateSeatIdentity,
@@ -40,7 +38,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;
@@ -91,6 +90,26 @@ function normalizeContinueSeatId(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";
@@ -168,50 +187,37 @@ function sleepSync(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
-function findJoinableSessionName(currentPath = process.cwd(), seatId = 2) {
-  const normalizedSeatId = normalizeSeatId(seatId);
-  const anchorSeatId = getPartnerSeatId(normalizedSeatId);
-  if (!normalizedSeatId || !anchorSeatId || isAnchorSeat(normalizedSeatId)) {
-    return null;
-  }
-
+function findExistingSessionName(currentPath = process.cwd()) {
   const candidates = listSessionNames()
     .map((sessionName) => {
       const sessionPaths = getSessionPaths(sessionName);
       const controller = readJson(sessionPaths.controllerPath, null);
-      const anchorPaths = getSeatPaths(sessionName, anchorSeatId);
-      const seatPaths = getSeatPaths(sessionName, normalizedSeatId);
-      const anchorMeta = readJson(anchorPaths.metaPath, null);
-      const anchorStatus = readJson(anchorPaths.statusPath, null);
-      const seatMeta = readJson(seatPaths.metaPath, null);
-      const seatStatus = readJson(seatPaths.statusPath, null);
-      const stopRequest = readJson(sessionPaths.stopPath, null);
+      const seats = listSeatIds(sessionName)
+        .map((seatId) => buildSeatReport(sessionName, seatId))
+        .filter((entry) => entry !== null);
 
-      const cwd = controller?.cwd || anchorStatus?.cwd || anchorMeta?.cwd || seatStatus?.cwd || seatMeta?.cwd || null;
+      const cwd = controller?.cwd || seats[0]?.cwd || null;
       if (!matchesWorkingPath(cwd, currentPath)) {
         return null;
       }
 
-      const anchorWrapperPid = anchorStatus?.pid || anchorMeta?.pid || null;
-      const anchorChildPid = anchorStatus?.childPid || anchorMeta?.childPid || null;
-      const seatWrapperPid = seatStatus?.pid || seatMeta?.pid || null;
-      const seatChildPid = seatStatus?.childPid || seatMeta?.childPid || null;
-      const anchorLive = isPidAlive(anchorWrapperPid) || isPidAlive(anchorChildPid);
-      const seatLive = isPidAlive(seatWrapperPid) || isPidAlive(seatChildPid);
-      const stopRequestedAtMs = Date.parse(stopRequest?.requestedAt || "");
-      const createdAtMs = Date.parse(controller?.createdAt || anchorMeta?.startedAt || anchorStatus?.updatedAt || "");
-
-      if (!anchorLive || seatLive) {
+      const controllerPid = controller?.pid || null;
+      const controllerLive = isPidAlive(controllerPid);
+      if (seats.length === 0 && !controllerLive) {
         return null;
       }
 
-      if (Number.isFinite(stopRequestedAtMs) && Number.isFinite(createdAtMs) && stopRequestedAtMs > createdAtMs) {
-        return null;
-      }
+      const createdAtMs = Date.parse(
+        controller?.createdAt ||
+        seats
+          .map((seat) => seat.startedAt || seat.updatedAt || "")
+          .find((value) => value) ||
+        ""
+      );
 
       return {
         sessionName,
-        createdAtMs,
+        createdAtMs: Number.isFinite(createdAtMs) ? createdAtMs : 0,
       };
     })
     .filter((entry) => entry !== null)
@@ -220,10 +226,10 @@ function findJoinableSessionName(currentPath = process.cwd(), seatId = 2) {
   return candidates[0]?.sessionName || null;
 }
 
-function waitForJoinableSessionName(currentPath = process.cwd(), seatId = 2, timeoutMs = SEAT_JOIN_WAIT_MS) {
+function waitForExistingSessionName(currentPath = process.cwd(), timeoutMs = SEAT_JOIN_WAIT_MS) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
-    const sessionName = findJoinableSessionName(currentPath, seatId);
+    const sessionName = findExistingSessionName(currentPath);
     if (sessionName) {
       return sessionName;
     }
@@ -234,11 +240,31 @@ function waitForJoinableSessionName(currentPath = process.cwd(), seatId = 2, tim
 }
 
 function resolveSessionName(currentPath = process.cwd(), seatId = 1) {
-  if (isAnchorSeat(seatId)) {
-    return createSessionName(currentPath);
+  const existingSessionName = findExistingSessionName(currentPath);
+  if (!existingSessionName) {
+    const normalizedSeatId = normalizeSeatId(seatId) || 1;
+    const joinWaitMs = Math.min(1000, Math.max(0, normalizedSeatId - 1) * 250);
+    const waitedSessionName = waitForExistingSessionName(currentPath, joinWaitMs);
+    if (!waitedSessionName) {
+      return createSessionName(currentPath);
+    }
+    const conflictingWaitedSeat = buildSeatReport(waitedSessionName, seatId);
+    if (conflictingWaitedSeat) {
+      throw new Error(
+        `Seat ${seatId} is already armed in this cwd. Stop it first or choose another seat number.`
+      );
+    }
+    return waitedSessionName;
+  }
+
+  const conflictingSeat = buildSeatReport(existingSessionName, seatId);
+  if (conflictingSeat) {
+    throw new Error(
+      `Seat ${seatId} is already armed in this cwd. Stop it first or choose another seat number.`
+    );
   }
 
-  return waitForJoinableSessionName(currentPath, seatId);
+  return existingSessionName;
 }
 
 function parseAnswerEntries(text) {
@@ -440,49 +466,30 @@ 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",
+    type: "muuuuse_relay",
     sessionName,
-    challenge,
     chainId: entry.chainId,
     hop: entry.hop,
     id: entry.id,
-    seatId: entry.seatId,
+    sourceSeatId: normalizeSeatId(entry.sourceSeatId || entry.seatId),
+    targetSeatId: normalizeSeatId(entry.targetSeatId),
     origin: entry.origin,
-    phase: entry.phase || "final_answer",
+    phase: getRelayPhase(entry),
     createdAt: entry.createdAt,
     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,
@@ -516,24 +523,6 @@ function getSeatDirIfExists(sessionName, seatId) {
   return null;
 }
 
-function readSeatChallenge(paths, sessionName) {
-  const record = readJson(paths.challengePath, null);
-  if (
-    !record ||
-    record.sessionName !== sessionName ||
-    typeof record.challenge !== "string" ||
-    typeof record.publicKey !== "string"
-  ) {
-    return null;
-  }
-
-  return {
-    challenge: record.challenge,
-    publicKey: record.publicKey.trim(),
-    createdAt: record.createdAt || null,
-  };
-}
-
 function normalizeRelayPayloadForTyping(text) {
   return String(text || "")
     .replace(/\r/g, "")
@@ -599,7 +588,7 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
   }
 
   try {
-    child.write("\n");
+    child.write("\r");
   } catch {
     return false;
   }
@@ -610,25 +599,20 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
 class ArmedSeat {
   constructor(options) {
     this.seatId = options.seatId;
-    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);
     if (this.continueSeatId === this.seatId) {
       throw new Error(`\`muuuuse ${this.seatId}\` cannot continue to itself.`);
     }
-    this.sessionName = resolveSessionName(this.cwd, this.seatId);
-    if (!this.sessionName) {
-      throw new Error(
-        `No armed \`muuuuse ${this.partnerSeatId}\` seat is waiting in this cwd. Run \`muuuuse ${this.partnerSeatId}\` first.`
-      );
+    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);
     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);
-    this.partnerOffset = getFileSize(this.partnerPaths.eventsPath);
 
     this.child = null;
     this.childPid = null;
@@ -641,17 +625,11 @@ class ArmedSeat {
     this.stdinCleanup = null;
     this.resizeCleanup = null;
     this.forceKillTimer = null;
-    this.identity = null;
+    this.identity = loadOrCreateSeatIdentity(this.paths);
     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,
@@ -672,11 +650,7 @@ class ArmedSeat {
       cwd: this.cwd,
       createdAt: current.createdAt || this.startedAt,
       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,
+      pid: process.pid,
       ...extra,
     });
   }
@@ -688,13 +662,14 @@ 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,
       childPid: this.childPid,
+      publicKey: this.identity?.publicKey || null,
       command: [resolveShell(), ...resolveShellArgs(resolveShell())],
       startedAt: this.startedAt,
       ...extra,
@@ -704,190 +679,24 @@ 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,
       childPid: this.childPid,
+      publicKey: this.identity?.publicKey || null,
       relayCount: this.relayCount,
       updatedAt: new Date().toISOString(),
       ...extra,
     });
   }
 
-  initializeTrustMaterial() {
-    this.identity = loadOrCreateSeatIdentity(this.paths);
-
-    if (!isAnchorSeat(this.seatId)) {
-      return;
-    }
-
-    writeJson(this.paths.challengePath, {
-      sessionName: this.sessionName,
-      challenge: createId(48),
-      publicKey: this.identity.publicKey,
-      createdAt: new Date().toISOString(),
-    });
-    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 });
-  }
-
-  syncTrustState() {
-    if (!this.identity) {
-      this.initializeTrustMaterial();
-    }
-
-    if (isAnchorSeat(this.seatId)) {
-      this.syncSeatOneTrust();
-      return;
-    }
-
-    this.syncSeatTwoTrust();
-  }
-
-  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;
-    }
-
-    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;
-    }
-
-    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 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;
-    }
-
-    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(),
-      });
-    }
-
-    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
-      )
-    );
-
-    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;
-  }
-
-  isPaired() {
-    return this.trustState.phase === "paired" &&
-      typeof this.trustState.challenge === "string" &&
-      typeof this.trustState.peerPublicKey === "string";
-  }
-
   launchShell() {
     ensureDir(this.paths.dir);
     fs.rmSync(this.paths.pipePath, { force: true });
     clearStaleStopRequest(this.sessionPaths.stopPath, this.startedAtMs);
-    this.initializeTrustMaterial();
     this.writeController();
 
     const shell = resolveShell();
@@ -904,7 +713,7 @@ class ArmedSeat {
 
     this.childPid = this.child.pid;
     this.writeMeta();
-    this.writeStatus({ state: "running", trust: this.trustState.phase });
+    this.writeStatus({ state: "running" });
 
     this.child.onData((data) => {
       fs.appendFileSync(this.paths.pipePath, data);
@@ -1038,9 +847,19 @@ class ArmedSeat {
     }
   }
 
-  partnerIsLive() {
-    const partner = readJson(this.partnerPaths.statusPath, null);
-    return Boolean(partner?.pid && isPidAlive(partner.pid));
+  getConfiguredTargets() {
+    const targets = [...this.continueTargets];
+    if (this.continueSeatId && !targets.some((target) => target.seatId === this.continueSeatId)) {
+      targets.push({
+        seatId: this.continueSeatId,
+        flowMode: this.flowMode,
+      });
+    }
+    return targets;
+  }
+
+  shouldCaptureCommentary() {
+    return this.getConfiguredTargets().some((target) => target.flowMode === "on");
   }
 
   stopRequested() {
@@ -1053,109 +872,80 @@ class ArmedSeat {
     return Number.isFinite(requestedAtMs) && requestedAtMs > this.startedAtMs;
   }
 
-  findContinuationTarget() {
-    if (!this.continueSeatId) {
+  hasAuthorizedSource(sourceSeatId) {
+    const desiredSeatId = normalizeSeatId(sourceSeatId);
+    if (!desiredSeatId) {
+      return false;
+    }
+
+    return this.getConfiguredTargets().some((target) => target.seatId === desiredSeatId);
+  }
+
+  readSourcePublicKey(sourceSeatId) {
+    const desiredSeatId = normalizeSeatId(sourceSeatId);
+    if (!desiredSeatId) {
       return null;
     }
 
-    const candidates = listSessionNames()
-      .map((sessionName) => {
-        if (!getSeatDirIfExists(sessionName, this.continueSeatId)) {
-          return null;
-        }
+    const sourcePaths = getSeatPaths(this.sessionName, desiredSeatId);
+    const sourceMeta = readJson(sourcePaths.metaPath, null);
+    if (typeof sourceMeta?.publicKey === "string" && sourceMeta.publicKey.trim()) {
+      return sourceMeta.publicKey.trim();
+    }
 
-        const seat = buildSeatReport(sessionName, this.continueSeatId);
-        if (!seat || !matchesWorkingPath(seat.cwd, this.cwd)) {
-          return null;
-        }
+    try {
+      const key = fs.readFileSync(sourcePaths.publicKeyPath, "utf8").trim();
+      return key || null;
+    } catch {
+      return null;
+    }
+  }
 
-        const updatedAtMs = Date.parse(seat.updatedAt || seat.startedAt || "");
-        return {
-          seat,
-          sessionName,
-          updatedAtMs: Number.isFinite(updatedAtMs) ? updatedAtMs : 0,
-        };
-      })
-      .filter((entry) => entry !== null)
-      .sort((left, right) => right.updatedAtMs - left.updatedAtMs);
+  findLinkedTarget(targetSeatId) {
+    const desiredSeatId = normalizeContinueSeatId(targetSeatId);
+    if (!desiredSeatId) {
+      return null;
+    }
 
-    if (candidates.length === 0) {
+    const seat = buildSeatReport(this.sessionName, desiredSeatId);
+    if (!seat || !matchesWorkingPath(seat.cwd, this.cwd)) {
       return null;
     }
 
-    const target = candidates[0];
     return {
-      seatId: target.seat.seatId,
-      sessionName: target.sessionName,
-      paths: getSeatPaths(target.sessionName, target.seat.seatId),
+      seatId: seat.seatId,
+      paths: getSeatPaths(this.sessionName, seat.seatId),
     };
   }
 
-  async pullPartnerEvents() {
-    const { nextOffset, text } = readAppendedText(this.partnerPaths.eventsPath, this.partnerOffset);
-    this.partnerOffset = nextOffset;
-    if (!text.trim() || !this.child || this.stopped || !this.isPaired()) {
-      return;
+  verifyInboundEntry(entry) {
+    const sourceSeatId = normalizeSeatId(entry?.sourceSeatId || entry?.seatId);
+    const targetSeatId = normalizeSeatId(entry?.targetSeatId);
+    const payload = sanitizeRelayText(entry?.text);
+    if (!sourceSeatId || targetSeatId !== this.seatId || !payload || !this.hasAuthorizedSource(sourceSeatId)) {
+      return false;
     }
 
-    const entries = parseAnswerEntries(text);
-    for (const entry of entries) {
-      if (this.stopped || this.stopRequested()) {
-        this.requestStop("stop_requested");
-        return;
-      }
-
-      if (!shouldAcceptInboundEntry(this.flowMode, entry)) {
-        continue;
-      }
+    const publicKey = this.readSourcePublicKey(sourceSeatId);
+    if (!publicKey || entry.publicKey !== publicKey || typeof entry.signature !== "string") {
+      return false;
+    }
 
-      const payload = sanitizeRelayText(entry.text);
-      const signaturePayload = buildAnswerSignaturePayload(this.sessionName, this.trustState.challenge, {
+    return verifyText(
+      buildAnswerSignaturePayload(this.sessionName, null, {
+        id: entry.id,
+        sourceSeatId,
+        targetSeatId,
         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)}`);
-    }
+      }),
+      entry.signature,
+      publicKey
+    );
   }
 
   async pullContinuationEvents() {
@@ -1172,7 +962,7 @@ class ArmedSeat {
         return;
       }
 
-      if (!shouldAcceptInboundEntry(this.flowMode, entry)) {
+      if (!this.verifyInboundEntry(entry)) {
         continue;
       }
 
@@ -1389,7 +1179,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: this.flowMode === "on" }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1398,7 +1188,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: this.flowMode === "on" }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1407,7 +1197,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.lastMessageId,
         this.liveState.captureSinceMs,
-        { flowMode: this.flowMode === "on" }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.lastMessageId = result.lastMessageId;
       this.liveState.offset = result.fileSize;
@@ -1440,7 +1230,7 @@ class ArmedSeat {
     }
 
     const payload = sanitizeRelayText(entry.text);
-    if (!payload || !this.identity || !this.trustState.challenge) {
+    if (!payload) {
       return;
     }
 
@@ -1459,59 +1249,66 @@ class ArmedSeat {
     const pendingInboundContext = this.getPendingInboundContext();
 
     const entryId = entry.id || createId(12);
-    const signedEntry = {
+    const relayEntry = {
       id: entryId,
       type: "answer",
       seatId: this.seatId,
+      sourceSeatId: this.seatId,
       origin: entry.origin || "unknown",
       phase: entry.phase || "final_answer",
       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,
     };
-    signedEntry.signature = signText(
-      buildAnswerSignaturePayload(this.sessionName, this.trustState.challenge, signedEntry),
-      this.identity.privateKey
-    );
-    appendJsonl(this.paths.eventsPath, signedEntry);
-    this.forwardContinuation(signedEntry);
+
+    appendJsonl(this.paths.eventsPath, relayEntry);
+    this.forwardContinuation(relayEntry);
     this.rememberEmittedAnswer(answerKey);
 
     this.log(`[${this.seatId}] ${previewText(payload)}`);
   }
 
-  forwardContinuation(signedEntry) {
-    if (!this.continueSeatId) {
+  forwardContinuation(relayEntry) {
+    const targets = this.getConfiguredTargets();
+    if (targets.length === 0) {
       return;
     }
 
-    const target = this.findContinuationTarget();
-    if (!target) {
-      this.log(`[${this.seatId}] continue ${this.continueSeatId} unavailable`);
-      return;
-    }
+    for (const targetEntry of targets) {
+      if (!shouldAcceptInboundEntry(targetEntry.flowMode, relayEntry)) {
+        continue;
+      }
+
+      const target = this.findLinkedTarget(targetEntry.seatId);
+      if (!target) {
+        this.log(`[${this.seatId}] link ${targetEntry.seatId} unavailable`);
+        continue;
+      }
 
-    const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, signedEntry);
-    appendJsonl(target.paths.continuePath, continuationEntry);
-    this.log(`[${this.seatId} => ${target.seatId}] ${previewText(continuationEntry.text)}`);
+      const continuationEntry = buildContinuationEntry(
+        this.sessionName,
+        target.seatId,
+        relayEntry,
+        targetEntry.flowMode
+      );
+      continuationEntry.publicKey = this.identity.publicKey;
+      continuationEntry.signature = signText(
+        buildAnswerSignaturePayload(this.sessionName, null, continuationEntry),
+        this.identity.privateKey
+      );
+      appendJsonl(target.paths.continuePath, continuationEntry);
+      this.log(`[${this.seatId} => ${target.seatId}] ${previewText(continuationEntry.text)}`);
+    }
   }
 
   async tick() {
     if (this.stopRequested()) {
-      this.writeStatus({
-        state: "stopping",
-        partnerLive: this.partnerIsLive(),
-        trust: this.trustState.phase,
-      });
+      this.writeStatus({ state: "stopping" });
       this.requestStop("stop_requested");
       return;
     }
 
-    this.syncTrustState();
-    await this.pullPartnerEvents();
     await this.pullContinuationEvents();
     if (this.stopped || this.stopRequested()) {
       this.requestStop("stop_requested");
@@ -1530,9 +1327,6 @@ class ArmedSeat {
       cwd: live.cwd,
       log: live.log,
       lastAnswerAt: live.lastAnswerAt,
-      partnerLive: this.partnerIsLive(),
-      trust: this.trustState.phase,
-      challengeReady: Boolean(this.trustState.challenge),
     });
   }
 
@@ -1544,15 +1338,17 @@ 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}.`);
+    this.log(`Seat ${this.seatId} default relay mode is flow ${this.flowMode}.`);
     if (this.continueSeatId) {
       this.log(`Seat ${this.seatId} continues to seat ${this.continueSeatId}.`);
     }
-    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.`);
+    const configuredTargets = this.getConfiguredTargets();
+    if (configuredTargets.length > 0) {
+      this.log(
+        `Seat ${this.seatId} links signed relay targets: ${configuredTargets.map((target) => `${target.seatId}:${target.flowMode}`).join(", ")}.`
+      );
     }
+    this.log("Signed relays are accepted only from seats that this seat links back to.");
     this.log("Run `muuuuse status` or `muuuuse stop` from any terminal.");
 
     try {
@@ -1650,6 +1446,7 @@ function buildSeatReport(sessionName, seatId) {
     state: wrapperLive ? status?.state || "running" : "orphaned_child",
     flowMode: status?.flowMode || meta?.flowMode || "off",
     continueSeatId: status?.continueSeatId || meta?.continueSeatId || null,
+    continueTargets: normalizeContinueTargets(status?.continueTargets || meta?.continueTargets),
     wrapperPid,
     childPid,
     wrapperLive,
@@ -1660,10 +1457,8 @@ function buildSeatReport(sessionName, seatId) {
     relayCount: status?.relayCount || 0,
     log: status?.log || null,
     startedAt: meta?.startedAt || null,
-    trust: status?.trust || null,
     updatedAt: status?.updatedAt || null,
     lastAnswerAt: status?.lastAnswerAt || null,
-    partnerLive: Boolean(status?.partnerLive),
   };
 }
 

package/src/util.js

@@ -175,18 +175,6 @@ 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);
   try {
@@ -282,17 +270,19 @@ function listSessionNames() {
 
 function usage() {
   return [
-    `${BRAND} arms regular terminals in isolated odd/even pairs and relays assistant output between each pair.`,
+    `${BRAND} arms regular terminals and relays assistant output across signed terminal links.`,
     "",
     "Usage:",
     "  muuuuse 1",
     "  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 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",
@@ -300,14 +290,14 @@ function usage() {
     "  muuuuse status",
     "",
     "Flow:",
-    "  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. 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.",
+    "  1. Run `muuuuse <seat>` in the terminal you want to arm.",
+    "  2. All armed seats in the same cwd join one relay graph.",
+    "  3. Use `link <seat> flow on|off ...` to define each outbound relay edge.",
+    "  4. `flow on` sends commentary and final answers on that edge. `flow off` sends final answers only.",
+    "  5. `continue <seat>` is shorthand for one outbound link that uses the seat's default `flow on|off`.",
+    "  6. Every forwarded relay is signed with the sender seat's key.",
+    "  7. A seat only accepts signed inbound relays from seats it links back to.",
+    "  8. Use those armed shells normally.",
     "  9. Run `muuuuse status` or `muuuuse stop` from any shell.",
     "",
     "Notes:",
@@ -325,9 +315,7 @@ module.exports = {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
-  getPartnerSeatId,
   loadOrCreateSeatIdentity,
-  isAnchorSeat,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,