muuuuse 3.1.1 → 3.3.2

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 when the sender linked to that target, 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 senders that linked the target seat 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": "3.1.1",
-  "description": "🔌Muuuuse arms regular terminals in isolated pairs and can continue relay output into any other armed seat.",
+  "version": "3.3.2",
+  "description": "🔌Muuuuse arms regular terminals and relays assistant output across signed terminal links.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"

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)) {
@@ -59,8 +59,8 @@ async function main(argv = process.argv.slice(2)) {
     const { flowMode, continueSeatId, continueTargets } = parseSeatOptions(command, argv.slice(1));
     const seat = new ArmedSeat({
       cwd: process.cwd(),
-      continueTargets,
       continueSeatId,
+      continueTargets,
       flowMode,
       seatId,
     });
@@ -81,15 +81,11 @@ function renderSeatStatus(seat) {
     `child ${seat.childPid || "-"}`,
   ];
 
-  if (seat.partnerLive) {
-    bits.push("peer live");
-  }
-  const renderedLinks = renderLinkTargets(seat);
-  if (renderedLinks) {
-    bits.push(`link ${renderedLinks}`);
+  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}`);
@@ -105,21 +101,10 @@ function renderSeatStatus(seat) {
   return output;
 }
 
-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);
-  }
-  if (targets.length === 0) {
-    return "";
-  }
-  return targets.map((target) => `${target.targetSeatId}:${target.flowMode}`).join(", ");
+function renderLinkTargets(targets) {
+  return targets
+    .map((target) => `${target.seatId}:${target.flowMode}`)
+    .join(", ");
 }
 
 function parseSeatOptions(command, args) {
@@ -127,98 +112,121 @@ function parseSeatOptions(command, args) {
   let flowMode = "off";
   let continueSeatId = null;
   let continueTargets = [];
-  if (args.length === 0) {
-    return { flowMode, continueSeatId, continueTargets };
-  }
+  let index = 0;
 
-  if (String(args[0] || "").trim().toLowerCase() === "link") {
-    const parsedLinks = parseLinkTargets(args.slice(1), seatId, flowMode);
-    if (parsedLinks.consumed === args.length - 1 && parsedLinks.consumed > 0) {
-      return {
-        flowMode: parsedLinks.flowMode,
-        continueSeatId: parsedLinks.continueTargets[0]?.targetSeatId || null,
-        continueTargets: parsedLinks.continueTargets,
-      };
-    }
-  } else {
-    let index = 0;
-
-    const flowToken = String(args[index] || "").trim().toLowerCase();
-    const flowModeToken = String(args[index + 1] || "").trim().toLowerCase();
-    if (flowToken === "flow" && (flowModeToken === "on" || flowModeToken === "off")) {
-      flowMode = flowModeToken;
-      index += 2;
+  for (; index < args.length;) {
+    const token = String(args[index] || "").trim().toLowerCase();
+
+    if (token === "flow") {
+      const nextFlowMode = parseFlowModeToken(args[index + 1]);
+      if (nextFlowMode) {
+        flowMode = nextFlowMode;
+        index += 2;
+        continue;
+      }
+      break;
     }
 
-    const continueToken = String(args[index] || "").trim().toLowerCase();
-    const targetSeatId = normalizeSeatId(args[index + 1]);
-    if (continueToken === "continue" && targetSeatId) {
-      continueSeatId = targetSeatId;
-      continueTargets = [{ targetSeatId, flowMode }];
-      index += 2;
+    if (token === "continue") {
+      const targetSeatId = normalizeSeatId(args[index + 1]);
+      if (targetSeatId && targetSeatId !== seatId) {
+        continueSeatId = targetSeatId;
+        index += 2;
+        continue;
+      }
+      break;
     }
 
-    if (index === args.length) {
-      return { flowMode, continueSeatId, continueTargets };
+    if (token === "link") {
+      const parsed = parseLinkTargets(seatId, args, index + 1);
+      if (!parsed) {
+        break;
+      }
+
+      continueTargets = mergeTargets(continueTargets, parsed.continueTargets);
+      index = parsed.nextIndex;
+      continue;
     }
+
+    break;
+  }
+
+  if (index === args.length) {
+    return { flowMode, continueSeatId, continueTargets };
   }
 
   throw new Error(
-    `\`muuuuse ${command}\` accepts no extra arguments or \`link <seat> flow on [<seat> flow off ...]\`. Run it directly in the terminal you want to arm.`
+    `\`muuuuse ${command}\` accepts \`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 parseLinkTargets(args, seatId, defaultFlowMode) {
-  const partnerSeatId = seatId ? getPartnerSeatId(seatId) : null;
+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 = [];
-  let flowMode = defaultFlowMode;
-  let consumed = 0;
 
-  while (consumed < args.length) {
-    const targetSeatId = normalizeSeatId(args[consumed]);
-    if (!targetSeatId) {
+  while (index < args.length) {
+    const targetSeatId = normalizeSeatId(args[index]);
+    if (!targetSeatId || targetSeatId === seatId) {
       break;
     }
 
-    const targetFlowMode = parseFlowModeToken(args[consumed + 1], args[consumed + 2]);
-    if (!targetFlowMode) {
+    if (String(args[index + 1] || "").trim().toLowerCase() !== "flow") {
       break;
     }
 
-    if (targetSeatId === partnerSeatId) {
-      flowMode = targetFlowMode;
-    } else {
-      upsertTarget(continueTargets, {
-        targetSeatId,
-        flowMode: targetFlowMode,
-      });
+    const targetFlowMode = parseFlowModeToken(args[index + 2]);
+    if (!targetFlowMode) {
+      break;
     }
 
-    consumed += 3;
+    upsertTarget(continueTargets, {
+      seatId: targetSeatId,
+      flowMode: targetFlowMode,
+    });
+
+    index += 3;
+  }
+
+  if (index === startIndex) {
+    return null;
   }
 
-  return { consumed, continueTargets, flowMode };
+  return {
+    continueTargets,
+    nextIndex: index,
+  };
 }
 
-function parseFlowModeToken(flowToken, modeToken) {
-  const normalizedFlowToken = String(flowToken || "").trim().toLowerCase();
-  const normalizedModeToken = String(modeToken || "").trim().toLowerCase();
-  if (normalizedFlowToken === "flow" && (normalizedModeToken === "on" || normalizedModeToken === "off")) {
-    return normalizedModeToken;
+function parseFlowModeToken(value) {
+  const token = String(value || "").trim().toLowerCase();
+  if (token === "on" || token === "off") {
+    return token;
   }
   return null;
 }
 
 function upsertTarget(targets, nextTarget) {
-  const existingIndex = targets.findIndex((entry) => entry.targetSeatId === nextTarget.targetSeatId);
-  if (existingIndex >= 0) {
-    targets[existingIndex] = nextTarget;
+  const currentIndex = targets.findIndex((target) => target.seatId === nextTarget.seatId);
+  if (currentIndex === -1) {
+    targets.push(nextTarget);
     return;
   }
-  targets.push(nextTarget);
+
+  targets[currentIndex] = nextTarget;
 }
 
 module.exports = {
   main,
-  parseSeatOptions,
 };