muuuuse 3.1.1 → 3.3.2

package/src/runtime.js

@@ -20,12 +20,10 @@ const {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
-  getPartnerSeatId,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,
   hashText,
-  isAnchorSeat,
   isPidAlive,
   listSeatIds,
   loadOrCreateSeatIdentity,
@@ -40,9 +38,9 @@ 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 TYPE_SUBMIT_DELAY_MS = 60;
 const MIRROR_SUPPRESSION_WINDOW_MS = 30 * 1000;
 const PENDING_RELAY_CONTEXT_TTL_MS = 2 * 60 * 1000;
 const EMITTED_ANSWER_TTL_MS = 5 * 60 * 1000;
@@ -92,24 +90,24 @@ function normalizeContinueSeatId(value) {
   return seatId || null;
 }
 
-function normalizeContinueTargets(targets, defaultFlowMode = "off") {
-  const normalized = [];
-  const seen = new Set();
-
-  for (const entry of Array.isArray(targets) ? targets : []) {
-    const targetSeatId = normalizeSeatId(entry?.targetSeatId ?? entry?.seatId ?? entry);
-    if (!targetSeatId || seen.has(targetSeatId)) {
-      continue;
-    }
-
-    seen.add(targetSeatId);
-    normalized.push({
-      targetSeatId,
-      flowMode: normalizeFlowMode(entry?.flowMode ?? entry?.flow ?? defaultFlowMode),
-    });
+function normalizeContinueTargets(value) {
+  if (!Array.isArray(value)) {
+    return [];
   }
 
-  return normalized;
+  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() {
@@ -189,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)
@@ -241,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;
     }
@@ -255,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;
   }
 
-  return waitForJoinableSessionName(currentPath, seatId);
+  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 existingSessionName;
 }
 
 function parseAnswerEntries(text) {
@@ -461,50 +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",
-    flowMode: entry.flowMode || "off",
+    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,
@@ -512,7 +497,6 @@ function buildContinuationEntry(sourceSessionName, targetSeatId, entry) {
     chainId: entry.chainId,
     hop: entry.hop,
     sourceAnswerId: entry.id,
-    flowMode: entry.flowMode || null,
     publicKey: entry.publicKey || null,
     signature: entry.signature || null,
   };
@@ -539,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, "")
@@ -621,14 +587,6 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
     return false;
   }
 
-  // Some TUIs treat fast, chunked relay typing as paste input and suppress an
-  // immediate Enter. A short settle delay keeps submit behavior reliable.
-  await sleep(TYPE_SUBMIT_DELAY_MS);
-
-  if (shouldAbort() || !child) {
-    return false;
-  }
-
   try {
     child.write("\r");
   } catch {
@@ -641,31 +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.continueTargets = normalizeContinueTargets(
-      options.continueTargets || (
-        options.continueSeatId ? [{ targetSeatId: options.continueSeatId, flowMode: options.flowMode }] : []
-      ),
-      this.flowMode
-    );
-    this.continueSeatId = this.continueTargets[0]?.targetSeatId || normalizeContinueSeatId(options.continueSeatId);
+    this.continueSeatId = normalizeContinueSeatId(options.continueSeatId);
+    this.continueTargets = normalizeContinueTargets(options.continueTargets);
     this.cwd = normalizeWorkingPath(options.cwd);
-    if (this.continueTargets.some((target) => target.targetSeatId === this.seatId)) {
+    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;
@@ -678,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,
@@ -709,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,
     });
   }
@@ -725,7 +662,6 @@ class ArmedSeat {
   writeMeta(extra = {}) {
     writeJson(this.paths.metaPath, {
       seatId: this.seatId,
-      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       flowMode: this.flowMode,
       continueSeatId: this.continueSeatId,
@@ -733,6 +669,7 @@ class ArmedSeat {
       cwd: this.cwd,
       pid: process.pid,
       childPid: this.childPid,
+      publicKey: this.identity?.publicKey || null,
       command: [resolveShell(), ...resolveShellArgs(resolveShell())],
       startedAt: this.startedAt,
       ...extra,
@@ -742,7 +679,6 @@ class ArmedSeat {
   writeStatus(extra = {}) {
     writeJson(this.paths.statusPath, {
       seatId: this.seatId,
-      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       flowMode: this.flowMode,
       continueSeatId: this.continueSeatId,
@@ -750,183 +686,17 @@ class ArmedSeat {
       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();
@@ -943,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);
@@ -1077,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() {
@@ -1092,116 +872,100 @@ class ArmedSeat {
     return Number.isFinite(requestedAtMs) && requestedAtMs > this.startedAtMs;
   }
 
-  shouldCaptureCommentary() {
-    return this.flowMode === "on" || this.continueTargets.some((target) => target.flowMode === "on");
+  sourceLinksToTarget(sourceSeatId, targetSeatId = this.seatId) {
+    const desiredSeatId = normalizeSeatId(sourceSeatId);
+    const desiredTargetSeatId = normalizeSeatId(targetSeatId);
+    if (!desiredSeatId || !desiredTargetSeatId) {
+      return false;
+    }
+
+    const sourcePaths = getSeatPaths(this.sessionName, desiredSeatId);
+    const sourceStatus = readJson(sourcePaths.statusPath, null);
+    const sourceMeta = readJson(sourcePaths.metaPath, null);
+    const sourceContinueSeatId = sourceStatus?.continueSeatId || sourceMeta?.continueSeatId || null;
+    const sourceContinueTargets = normalizeContinueTargets(
+      sourceStatus?.continueTargets || sourceMeta?.continueTargets
+    );
+
+    const configuredTargets = [...sourceContinueTargets];
+    if (
+      sourceContinueSeatId &&
+      !configuredTargets.some((target) => target.seatId === normalizeSeatId(sourceContinueSeatId))
+    ) {
+      configuredTargets.push({
+        seatId: normalizeSeatId(sourceContinueSeatId),
+        flowMode: normalizeFlowMode(sourceStatus?.flowMode || sourceMeta?.flowMode),
+      });
+    }
+
+    return configuredTargets.some((target) => target.seatId === desiredTargetSeatId);
   }
 
-  findContinuationTarget(targetSeatId) {
-    const normalizedTargetSeatId = normalizeSeatId(targetSeatId);
-    if (!normalizedTargetSeatId) {
+  readSourcePublicKey(sourceSeatId) {
+    const desiredSeatId = normalizeSeatId(sourceSeatId);
+    if (!desiredSeatId) {
       return null;
     }
 
-    const candidates = listSessionNames()
-      .map((sessionName) => {
-        if (!getSeatDirIfExists(sessionName, normalizedTargetSeatId)) {
-          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, normalizedTargetSeatId);
-        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.sourceLinksToTarget(sourceSeatId, targetSeatId)) {
+      return false;
     }
 
-    const entries = parseAnswerEntries(text);
-    for (const entry of entries) {
-      if (this.stopped || this.stopRequested()) {
-        this.requestStop("stop_requested");
-        return;
-      }
-
-      const inboundFlowMode = normalizeFlowMode(entry.flowMode || this.flowMode);
-      if (!shouldAcceptInboundEntry(inboundFlowMode, 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),
-        flowMode: inboundFlowMode,
         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() {
@@ -1218,8 +982,7 @@ class ArmedSeat {
         return;
       }
 
-      const continueFlowMode = normalizeFlowMode(entry.flowMode || this.flowMode);
-      if (!shouldAcceptInboundEntry(continueFlowMode, entry)) {
+      if (!this.verifyInboundEntry(entry)) {
         continue;
       }
 
@@ -1431,13 +1194,12 @@ class ArmedSeat {
     }
 
     const answers = [];
-    const captureCommentary = this.shouldCaptureCommentary();
     if (detectedAgent.type === "codex") {
       const result = readCodexAnswers(
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: captureCommentary }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1446,7 +1208,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.offset,
         this.liveState.captureSinceMs,
-        { flowMode: captureCommentary }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.offset = result.nextOffset;
       answers.push(...result.answers);
@@ -1455,7 +1217,7 @@ class ArmedSeat {
         this.liveState.sessionFile,
         this.liveState.lastMessageId,
         this.liveState.captureSinceMs,
-        { flowMode: captureCommentary }
+        { flowMode: this.shouldCaptureCommentary() }
       );
       this.liveState.lastMessageId = result.lastMessageId;
       this.liveState.offset = result.fileSize;
@@ -1488,7 +1250,7 @@ class ArmedSeat {
     }
 
     const payload = sanitizeRelayText(entry.text);
-    if (!payload || !this.identity || !this.trustState.challenge) {
+    if (!payload) {
       return;
     }
 
@@ -1507,65 +1269,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",
-      flowMode: this.flowMode,
       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.continueTargets.length === 0) {
+  forwardContinuation(relayEntry) {
+    const targets = this.getConfiguredTargets();
+    if (targets.length === 0) {
       return;
     }
 
-    for (const targetEntry of this.continueTargets) {
-      const target = this.findContinuationTarget(targetEntry.targetSeatId);
+    for (const targetEntry of targets) {
+      if (!shouldAcceptInboundEntry(targetEntry.flowMode, relayEntry)) {
+        continue;
+      }
+
+      const target = this.findLinkedTarget(targetEntry.seatId);
       if (!target) {
-        this.log(`[${this.seatId}] continue ${targetEntry.targetSeatId} unavailable`);
+        this.log(`[${this.seatId}] link ${targetEntry.seatId} unavailable`);
         continue;
       }
 
-      const continuationEntry = buildContinuationEntry(this.sessionName, target.seatId, {
-        ...signedEntry,
-        flowMode: targetEntry.flowMode,
-      });
+      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} ${targetEntry.flowMode}] ${previewText(continuationEntry.text)}`);
+      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");
@@ -1584,9 +1347,6 @@ class ArmedSeat {
       cwd: live.cwd,
       log: live.log,
       lastAnswerAt: live.lastAnswerAt,
-      partnerLive: this.partnerIsLive(),
-      trust: this.trustState.phase,
-      challengeReady: Boolean(this.trustState.challenge),
     });
   }
 
@@ -1598,17 +1358,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}.`);
-    if (this.continueTargets.length > 0) {
+    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}.`);
+    }
+    const configuredTargets = this.getConfiguredTargets();
+    if (configuredTargets.length > 0) {
       this.log(
-        `Seat ${this.seatId} continues to ${this.continueTargets.map((target) => `seat ${target.targetSeatId} (${target.flowMode})`).join(", ")}.`
+        `Seat ${this.seatId} links signed relay targets: ${configuredTargets.map((target) => `${target.seatId}:${target.flowMode}`).join(", ")}.`
       );
     }
-    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.`);
-    }
+    this.log("Signed relays are accepted when the sender linked to this seat.");
     this.log("Run `muuuuse status` or `muuuuse stop` from any terminal.");
 
     try {
@@ -1703,18 +1463,10 @@ function buildSeatReport(sessionName, seatId) {
 
   return {
     seatId,
-    partnerSeatId: status?.partnerSeatId || meta?.partnerSeatId || getPartnerSeatId(seatId),
     state: wrapperLive ? status?.state || "running" : "orphaned_child",
     flowMode: status?.flowMode || meta?.flowMode || "off",
     continueSeatId: status?.continueSeatId || meta?.continueSeatId || null,
-    continueTargets: normalizeContinueTargets(
-      status?.continueTargets || meta?.continueTargets || (
-        (status?.continueSeatId || meta?.continueSeatId)
-          ? [{ targetSeatId: status?.continueSeatId || meta?.continueSeatId, flowMode: status?.flowMode || meta?.flowMode || "off" }]
-          : []
-      ),
-      status?.flowMode || meta?.flowMode || "off"
-    ),
+    continueTargets: normalizeContinueTargets(status?.continueTargets || meta?.continueTargets),
     wrapperPid,
     childPid,
     wrapperLive,
@@ -1725,10 +1477,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),
   };
 }