muuuuse 5.5.4 → 7.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "5.5.4",
-  "description": "🔌Muuuuse arms regular terminals in isolated pairs and can continue relay output into any other armed seat.",
+  "version": "7.0.0",
+  "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.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"
@@ -40,8 +40,7 @@
   ],
   "scripts": {
     "test": "node test/cli.test.js",
-    "pack:local": "npm pack",
-    "prepublishOnly": "npm test"
+    "pack:local": "npm pack"
   },
   "dependencies": {
     "node-pty": "^1.1.0"

package/src/agents.js

@@ -468,7 +468,9 @@ function parseCodexAssistantLine(line, options = {}) {
     }
 
     const phase = String(entry.payload?.phase || "").trim().toLowerCase();
-    const relayablePhase = phase === "final_answer" || (flowMode && phase === "commentary");
+    // 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");
     if (!relayablePhase) {
       return null;
     }
@@ -481,7 +483,7 @@ function parseCodexAssistantLine(line, options = {}) {
     return {
       id: entry.payload.id || hashText(line),
       text,
-      phase: phase === "commentary" ? "commentary" : "final_answer",
+      phase: normalizedPhase,
       timestamp: entry.timestamp || entry.payload.timestamp || new Date().toISOString(),
     };
   } catch {

package/src/cli.js

@@ -1,4 +1,4 @@
-const { BRAND, getPartnerSeatId, normalizeSeatId, usage } = require("./util");
+const { BRAND, normalizeSeatId, usage } = require("./util");
 const { ArmedSeat, getStatusReport, stopAllSessions } = require("./runtime");
 
 async function main(argv = process.argv.slice(2)) {
@@ -56,12 +56,10 @@ async function main(argv = process.argv.slice(2)) {
 
   const seatId = normalizeSeatId(command);
   if (seatId) {
-    const { flowMode, continueSeatId, continueTargets } = parseSeatOptions(command, argv.slice(1));
+    const { continueTargets } = parseSeatOptions(command, argv.slice(1));
     const seat = new ArmedSeat({
       cwd: process.cwd(),
       continueTargets,
-      continueSeatId,
-      flowMode,
       seatId,
     });
     const code = await seat.run();
@@ -75,15 +73,11 @@ 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 || "-"}`,
   ];
 
-  if (seat.partnerLive) {
-    bits.push("peer live");
-  }
   const renderedLinks = renderLinkTargets(seat);
   if (renderedLinks) {
     bits.push(`link ${renderedLinks}`);
@@ -106,74 +100,77 @@ function renderSeatStatus(seat) {
 }
 
 function renderLinkTargets(seat) {
-  const targets = [];
-  if (seat.partnerSeatId) {
-    targets.push({
-      targetSeatId: seat.partnerSeatId,
-      flowMode: seat.flowMode || "off",
-    });
-  }
-  for (const target of Array.isArray(seat.continueTargets) ? seat.continueTargets : []) {
-    targets.push(target);
-  }
-
+  const targets = Array.isArray(seat.continueTargets) ? seat.continueTargets : [];
   return targets
-    .map((target) => `${target.targetSeatId}:${target.flowMode}`)
+    .map((target) => `${target.targetSeatId} (flow ${target.flowMode})`)
     .join(", ");
 }
 
 function parseSeatOptions(command, args) {
   const seatId = normalizeSeatId(command);
-  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) {
     const token = String(args[index] || "").trim().toLowerCase();
 
-    if (token === "flow") {
-      const flowToken = String(args[index + 1] || "").trim().toLowerCase();
-      if (flowToken === "on" || flowToken === "off") {
-        flowMode = flowToken;
-        index += 2;
-        continue;
-      }
-      break;
-    }
-
-    if (token === "continue") {
-      const parsedTargets = parseContinueTargets(args.slice(index + 1), flowMode);
-      if (parsedTargets.targets.length > 0) {
-        continueTargets = mergeTargets(continueTargets, parsedTargets.targets);
-        continueSeatId = continueTargets[0].targetSeatId;
-        index += 1 + parsedTargets.consumed;
-        continue;
-      }
-      break;
-    }
-
     if (token === "link") {
-      const parsedLinks = parseLinkTargets(args.slice(index + 1), seatId, flowMode);
+      const parsedLinks = parseLinkTargets(args.slice(index + 1), seatId);
       if (parsedLinks.consumed > 0) {
-        flowMode = parsedLinks.flowMode;
         continueTargets = mergeTargets(continueTargets, parsedLinks.continueTargets);
-        continueSeatId = continueTargets[0]?.targetSeatId || null;
+        hasExplicitTarget = true;
         index += 1 + parsedLinks.consumed;
         continue;
       }
       break;
     }
 
+    if (token === "continue") {
+      const targetSeatId = normalizeSeatId(args[index + 1]);
+      if (!targetSeatId) {
+        break;
+      }
+      upsertTarget(continueTargets, {
+        targetSeatId,
+        flowMode: seatFlowMode || "on",
+      });
+      hasExplicitTarget = true;
+      index += 2;
+      continue;
+    }
+
     break;
   }
 
   if (index === args.length) {
-    return { flowMode, continueSeatId, continueTargets };
+    if (seatFlowMode && !hasExplicitTarget) {
+      const partnerSeatId = seatId % 2 === 0 ? seatId - 1 : seatId + 1;
+      if (partnerSeatId > 0) {
+        upsertTarget(continueTargets, {
+          targetSeatId: partnerSeatId,
+          flowMode: seatFlowMode,
+        });
+      }
+    }
+    return { continueTargets };
   }
 
   throw new Error(
-    `\`muuuuse ${command}\` accepts no extra arguments, \`flow on\` / \`flow off\`, optional \`continue <seat>\`, or \`link <seat> flow on [<seat> flow off ...]\`. Run it directly in the terminal you want to arm.`
+    `\`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.`
   );
 }
 
@@ -189,32 +186,8 @@ function mergeTargets(existingTargets, nextTargets) {
   return merged;
 }
 
-function parseContinueTargets(args, defaultFlowMode) {
-  const targets = [];
-  let consumed = 0;
-
-  while (consumed < args.length) {
-    const targetSeatId = normalizeSeatId(args[consumed]);
-    if (!targetSeatId) {
-      break;
-    }
-
-    const nextFlowMode = parseFlowModeToken(args[consumed + 1], args[consumed + 2]);
-    const target = {
-      targetSeatId,
-      flowMode: nextFlowMode || defaultFlowMode,
-    };
-    upsertTarget(targets, target);
-    consumed += nextFlowMode ? 3 : 1;
-  }
-
-  return { consumed, targets };
-}
-
-function parseLinkTargets(args, seatId, defaultFlowMode) {
-  const partnerSeatId = seatId ? getPartnerSeatId(seatId) : null;
+function parseLinkTargets(args, seatId) {
   const continueTargets = [];
-  let flowMode = defaultFlowMode;
   let consumed = 0;
 
   while (consumed < args.length) {
@@ -228,19 +201,15 @@ function parseLinkTargets(args, seatId, defaultFlowMode) {
       break;
     }
 
-    if (targetSeatId === partnerSeatId) {
-      flowMode = targetFlowMode;
-    } else {
-      upsertTarget(continueTargets, {
-        targetSeatId,
-        flowMode: targetFlowMode,
-      });
-    }
+    upsertTarget(continueTargets, {
+      targetSeatId,
+      flowMode: targetFlowMode,
+    });
 
     consumed += 3;
   }
 
-  return { consumed, continueTargets, flowMode };
+  return { consumed, continueTargets };
 }
 
 function parseFlowModeToken(flowToken, modeToken) {

package/src/runtime.js

@@ -20,12 +20,10 @@ const {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
-  getPartnerSeatId,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,
   hashText,
-  isAnchorSeat,
   isPidAlive,
   listSeatIds,
   loadOrCreateSeatIdentity,
@@ -60,11 +58,6 @@ function normalizeFlowMode(flowMode) {
   return String(flowMode || "").trim().toLowerCase() === "on" ? "on" : "off";
 }
 
-function normalizeContinueSeatId(value) {
-  const seatId = normalizeSeatId(value);
-  return seatId || null;
-}
-
 function resolveShell() {
   const shell = String(process.env.SHELL || "").trim();
   return shell || "/bin/bash";
@@ -134,6 +127,11 @@ 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;
@@ -142,45 +140,33 @@ 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(), anchorSeatId = null) {
+  const targetAnchorSeatId = normalizeSeatId(anchorSeatId) || null;
   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 cwd = controller?.cwd || anchorStatus?.cwd || anchorMeta?.cwd || seatStatus?.cwd || seatMeta?.cwd || null;
+      const cwd = controller?.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 stopRequest = readJson(sessionPaths.stopPath, null);
       const stopRequestedAtMs = Date.parse(stopRequest?.requestedAt || "");
-      const createdAtMs = Date.parse(controller?.createdAt || anchorMeta?.startedAt || anchorStatus?.updatedAt || "");
+      const createdAtMs = Date.parse(controller?.createdAt || "");
 
-      if (!anchorLive || seatLive) {
+      if (Number.isFinite(stopRequestedAtMs) && Number.isFinite(createdAtMs) && stopRequestedAtMs > createdAtMs) {
         return null;
       }
 
-      if (Number.isFinite(stopRequestedAtMs) && Number.isFinite(createdAtMs) && stopRequestedAtMs > createdAtMs) {
-        return null;
+      if (targetAnchorSeatId) {
+        const controllerAnchorSeatId = normalizeSeatId(controller?.anchorSeatId);
+        if (controllerAnchorSeatId && controllerAnchorSeatId !== targetAnchorSeatId) {
+          return null;
+        }
+        if (!controllerAnchorSeatId && !getSeatDirIfExists(sessionName, targetAnchorSeatId)) {
+          return null;
+        }
       }
 
       return {
@@ -194,10 +180,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, anchorSeatId = null) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() <= deadline) {
-    const sessionName = findJoinableSessionName(currentPath, seatId);
+    const sessionName = findExistingSessionName(currentPath, anchorSeatId);
     if (sessionName) {
       return sessionName;
     }
@@ -208,11 +194,20 @@ function waitForJoinableSessionName(currentPath = process.cwd(), seatId = 2, tim
 }
 
 function resolveSessionName(currentPath = process.cwd(), seatId = 1) {
-  if (isAnchorSeat(seatId)) {
-    return createSessionName(currentPath);
+  const anchorSeatId = getAnchorSeatId(seatId);
+  const existing = findExistingSessionName(currentPath, anchorSeatId);
+  if (existing) {
+    return existing;
+  }
+
+  if (seatId % 2 === 0) {
+    const waited = waitForExistingSessionName(currentPath, SEAT_JOIN_WAIT_MS, anchorSeatId);
+    if (waited) {
+      return waited;
+    }
   }
 
-  return waitForJoinableSessionName(currentPath, seatId);
+  return createSessionName(currentPath);
 }
 
 function parseAnswerEntries(text) {
@@ -414,26 +409,6 @@ 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",
@@ -584,26 +559,52 @@ 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.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.cwd = normalizeWorkingPath(options.cwd);
-    if (this.continueSeatId === this.seatId || this.continueTargets.some((t) => t.targetSeatId === this.seatId)) {
-      throw new Error(`\`muuuuse ${this.seatId}\` cannot continue to itself.`);
+
+    // 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.continueTargets.some((t) => t.targetSeatId === this.seatId)) {
+      throw new Error(`\`muuuuse ${this.seatId}\` cannot relay 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.`
+        `Failed to create or find session in ${this.cwd}.`
       );
     }
     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);
+
+    // 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.child = null;
     this.childPid = null;
@@ -617,16 +618,11 @@ 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,
@@ -649,9 +645,6 @@ 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,
     });
   }
@@ -663,10 +656,7 @@ 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,
@@ -680,10 +670,7 @@ 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,
@@ -696,168 +683,84 @@ class ArmedSeat {
 
   initializeTrustMaterial() {
     this.identity = loadOrCreateSeatIdentity(this.paths);
-
-    if (!isAnchorSeat(this.seatId)) {
-      return;
-    }
-
+    const ownChallenge = createId(48);
     writeJson(this.paths.challengePath, {
       sessionName: this.sessionName,
-      challenge: createId(48),
+      challenge: ownChallenge,
       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 });
+    this.ownChallenge = ownChallenge;
   }
 
-  syncTrustState() {
+  syncTargetTrust() {
     if (!this.identity) {
       this.initializeTrustMaterial();
     }
 
-    if (isAnchorSeat(this.seatId)) {
-      this.syncSeatOneTrust();
-      return;
+    for (const target of this.continueTargets) {
+      this.syncOneTargetTrust(target.targetSeatId);
     }
-
-    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,
-      };
+  syncOneTargetTrust(targetSeatId) {
+    const trust = this.targetTrust[targetSeatId];
+    if (!trust || trust.phase === "paired") {
       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 });
+    // Cross-session target: relay goes through the continuation channel only.
+    if (!trust.sameSession) {
+      trust.phase = "paired";
+      trust.pairedAt = new Date().toISOString();
       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(),
-      });
+    // 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 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,
-      };
+    const targetChallenge = readSeatChallenge(targetPaths, this.sessionName);
+    if (!targetChallenge) {
+      trust.phase = "waiting_for_target";
       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(),
-      });
-    }
+    trust.challenge = targetChallenge.challenge;
+    trust.peerPublicKey = targetChallenge.publicKey;
+    trust.phase = "paired";
+    trust.pairedAt = 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
-      )
-    );
+    // Initialize offset to current file size so we only read new events.
+    this.targetOffsets[targetSeatId] = getFileSize(targetPaths.eventsPath);
+  }
 
-    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;
+  isTargetPaired(targetSeatId) {
+    const trust = this.targetTrust[targetSeatId];
+    return Boolean(trust && trust.phase === "paired");
   }
 
-  isPaired() {
-    return this.trustState.phase === "paired" &&
-      typeof this.trustState.challenge === "string" &&
-      typeof this.trustState.peerPublicKey === "string";
+  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));
   }
 
   launchShell() {
@@ -865,6 +768,7 @@ class ArmedSeat {
     fs.rmSync(this.paths.pipePath, { force: true });
     clearStaleStopRequest(this.sessionPaths.stopPath, this.startedAtMs);
     this.initializeTrustMaterial();
+    this.syncTargetTrust();
     this.writeController();
 
     const shell = resolveShell();
@@ -880,7 +784,7 @@ class ArmedSeat {
 
     this.childPid = this.child.pid;
     this.writeMeta();
-    this.writeStatus({ state: "running", trust: this.trustState.phase });
+    this.writeStatus({ state: "running", trust: this.getOverallTrustPhase() });
 
     this.child.onData((data) => {
       fs.appendFileSync(this.paths.pipePath, data);
@@ -1014,11 +918,6 @@ class ArmedSeat {
     }
   }
 
-  partnerIsLive() {
-    const partner = readJson(this.partnerPaths.statusPath, null);
-    return Boolean(partner?.pid && isPidAlive(partner.pid));
-  }
-
   stopRequested() {
     const request = readJson(this.sessionPaths.stopPath, null);
     if (!request?.requestedAt) {
@@ -1068,73 +967,6 @@ 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(this.flowMode, 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;
@@ -1149,10 +981,6 @@ class ArmedSeat {
         return;
       }
 
-      if (!shouldAcceptInboundEntry(this.flowMode, entry)) {
-        continue;
-      }
-
       const payload = sanitizeRelayText(entry.text);
       if (!payload) {
         continue;
@@ -1366,7 +1194,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: this.flowMode === "on" }
+        { flowMode: true }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1375,7 +1203,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: this.flowMode === "on" }
+        { flowMode: true }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1384,7 +1212,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.lastMessageId,
         this.liveState.captureSinceMs,
-        { flowMode: this.flowMode === "on" }
+        { flowMode: true }
       );
       this.liveState.lastMessageId = result.lastMessageId;
       this.liveState.offset = result.fileSize;
@@ -1417,7 +1245,11 @@ class ArmedSeat {
     }
 
     const payload = sanitizeRelayText(entry.text);
-    if (!payload || !this.identity || !this.trustState.challenge) {
+    if (!payload || !this.identity || !this.ownChallenge) {
+      return;
+    }
+
+    if (!this.hasAnyPairedTarget()) {
       return;
     }
 
@@ -1434,8 +1266,10 @@ 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 = {
       id: entryId,
       type: "answer",
@@ -1446,61 +1280,67 @@ class ArmedSeat {
       createdAt: entry.createdAt || new Date().toISOString(),
       chainId: pendingInboundContext?.chainId || entry.chainId || entryId,
       hop: pendingInboundContext ? pendingInboundContext.hop + 1 : 0,
-      challenge: this.trustState.challenge,
+      challenge: this.ownChallenge,
       publicKey: this.identity.publicKey,
     };
     signedEntry.signature = signText(
-      buildAnswerSignaturePayload(this.sessionName, this.trustState.challenge, signedEntry),
+      buildAnswerSignaturePayload(this.sessionName, this.ownChallenge, signedEntry),
       this.identity.privateKey
     );
     appendJsonl(this.paths.eventsPath, signedEntry);
-    this.forwardContinuation(signedEntry);
-    this.rememberEmittedAnswer(answerKey);
 
+    // Forward via continuation channel for cross-session targets.
+    for (const target of this.continueTargets) {
+      this.forwardContinuation(signedEntry, target);
+    }
+
+    this.rememberEmittedAnswer(answerKey);
     this.log(`[${this.seatId}] ${previewText(payload)}`);
   }
 
-  forwardContinuation(signedEntry) {
-    // Route to legacy single continueSeatId if set
-    if (this.continueSeatId) {
-      const target = this.findContinuationTarget();
-      if (!target) {
-        this.log(`[${this.seatId}] continue ${this.continueSeatId} unavailable`);
-        return;
-      }
-
-      const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, signedEntry);
-      appendJsonl(target.paths.continuePath, continuationEntry);
-      this.log(`[${this.seatId} => ${target.seatId}] ${previewText(continuationEntry.text)}`);
+  forwardContinuation(signedEntry, targetEntry) {
+    if (!shouldAcceptInboundEntry(targetEntry.flowMode, signedEntry)) {
+      return;
     }
 
-    // Route to all continueTargets with per-target flow modes
-    for (const targetEntry of this.continueTargets) {
-      const target = this.findContinuationTarget(targetEntry.targetSeatId);
-      if (!target) {
-        this.log(`[${this.seatId}] target ${targetEntry.targetSeatId} unavailable`);
-        continue;
+    // 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)}`);
       }
+      return;
+    }
 
-      const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, signedEntry);
-      appendJsonl(target.paths.continuePath, continuationEntry);
-      this.log(`[${this.seatId} => ${target.seatId} (${targetEntry.flowMode})] ${previewText(continuationEntry.text)}`);
+    // Cross-session target: find the target across sessions.
+    const target = this.findContinuationTarget(targetEntry.targetSeatId);
+    if (!target) {
+      return;
     }
+
+    const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, signedEntry);
+    appendJsonl(target.paths.continuePath, continuationEntry);
+    this.log(`[${this.seatId} => ${target.seatId} (${targetEntry.flowMode})] ${previewText(continuationEntry.text)}`);
   }
 
   async tick() {
     if (this.stopRequested()) {
       this.writeStatus({
         state: "stopping",
-        partnerLive: this.partnerIsLive(),
-        trust: this.trustState.phase,
+        trust: this.getOverallTrustPhase(),
       });
       this.requestStop("stop_requested");
       return;
     }
 
-    this.syncTrustState();
-    await this.pullPartnerEvents();
+    this.syncTargetTrust();
+    if (this.stopped || this.stopRequested()) {
+      this.requestStop("stop_requested");
+      return;
+    }
     await this.pullContinuationEvents();
     if (this.stopped || this.stopRequested()) {
       this.requestStop("stop_requested");
@@ -1515,13 +1355,11 @@ class ArmedSeat {
     this.writeStatus({
       state: live.state,
       agent: live.agent,
-      flowMode: this.flowMode,
       cwd: live.cwd,
       log: live.log,
       lastAnswerAt: live.lastAnswerAt,
-      partnerLive: this.partnerIsLive(),
-      trust: this.trustState.phase,
-      challengeReady: Boolean(this.trustState.challenge),
+      trust: this.getOverallTrustPhase(),
+      challengeReady: this.hasAnyPairedTarget(),
     });
   }
 
@@ -1533,18 +1371,9 @@ 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} (${t.flowMode})`).join(", ");
-      this.log(`Seat ${this.seatId} links to ${targets}.`);
-    }
-    if (isAnchorSeat(this.seatId)) {
-      this.log(`Seat ${this.seatId} generated the session key and is waiting for seat ${this.partnerSeatId} to sign it.`);
-    } else {
-      this.log(`Seat ${this.seatId} will sign the session key from seat ${this.partnerSeatId}, then relay goes live.`);
+      const targets = this.continueTargets.map((t) => `${t.targetSeatId} (flow ${t.flowMode})`).join(", ");
+      this.log(`Seat ${this.seatId} relays to ${targets}. Establishing trust.`);
     }
     this.log("Run `muuuuse status` or `muuuuse stop` from any terminal.");
 
@@ -1641,8 +1470,6 @@ function buildSeatReport(sessionName, seatId) {
   return {
     seatId,
     state: wrapperLive ? status?.state || "running" : "orphaned_child",
-    flowMode: status?.flowMode || meta?.flowMode || "off",
-    continueSeatId: status?.continueSeatId || meta?.continueSeatId || null,
     continueTargets: status?.continueTargets || meta?.continueTargets || [],
     wrapperPid,
     childPid,
@@ -1657,7 +1484,6 @@ 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";
+const BRAND = "🔌Muuuuse v7.0.0";
 const POLL_MS = 220;
 const MAX_RELAY_CHARS = 4000;
 const SESSION_MATCH_WINDOW_MS = 5 * 60 * 1000;
@@ -175,17 +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);
@@ -282,36 +271,28 @@ function listSessionNames() {
 
 function usage() {
   return [
-    `${BRAND} arms regular terminals in isolated odd/even pairs and relays assistant output between each pair.`,
+    `${BRAND} relay protocol for long-horizon zero-drift agentic code loops. agents relay output between terminals, converging to lucid conclusions.`,
     "",
     "Usage:",
     "  muuuuse 1",
-    "  muuuuse 1 flow on",
-    "  muuuuse 1 flow off",
-    "  muuuuse 1 flow on continue 3",
+    "  muuuuse 1 link 2 flow on",
+    "  muuuuse 1 link 2 flow on 3 flow off",
     "  muuuuse 2",
-    "  muuuuse 2 flow on",
-    "  muuuuse 2 flow off",
-    "  muuuuse 2 flow on continue 3",
+    "  muuuuse 2 link 3 flow on",
     "  muuuuse 3",
-    "  muuuuse 4",
-    "  muuuuse 4 flow on continue 1",
     "  muuuuse stop",
     "  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.",
-    "  9. Run `muuuuse status` or `muuuuse stop` from any shell.",
+    "  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.",
     "",
     "Notes:",
-    "  - `muuuuse stop` and `muuuuse status` work from another terminal or the same one.",
+    "  - Any seat can relay to any other seat independently.",
+    "  - `muuuuse stop` and `muuuuse status` work from any terminal.",
     "  - State lives under `~/.muuuuse`.",
   ].join("\n");
 }
@@ -325,9 +306,7 @@ module.exports = {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
-  getPartnerSeatId,
   loadOrCreateSeatIdentity,
-  isAnchorSeat,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,