muuuuse 1.4.2 → 1.5.0

package/README.md

@@ -5,6 +5,7 @@
 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
 - watch Codex, Claude, or Gemini for real final answers
 - inject that final answer into the other armed terminal
 - keep looping until you stop it
@@ -32,7 +33,7 @@ Terminal 2:
 muuuuse 2
 ```
 
-Now both shells are armed. Use them normally.
+Now both shells are armed. `muuuuse 1` generates the session key, `muuuuse 2` signs it, and only that signed pair relays. Use those shells normally.
 
 If you want Codex in one and Gemini in the other, start them inside the armed shells:
 
@@ -62,6 +63,7 @@ muuuuse stop
 
 - no tmux
 - state lives under `~/.muuuuse`
+- only the signed armed pair can exchange relay events
 - supported final-answer detection is built for Codex, Claude, and Gemini
 - `codeman` remains the larger transport/control layer; `muuuuse` stays local and minimal
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muuuuse",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "🔌Muuuuse arms two regular terminals and relays final answers between them.",
   "type": "commonjs",
   "bin": {

package/src/agents.js

@@ -128,6 +128,57 @@ function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs)
   return null;
 }
 
+function listOpenFilePaths(pid, rootPath) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return [];
+  }
+
+  const fdRoot = `/proc/${pid}/fd`;
+  try {
+    const rootPrefix = path.resolve(rootPath);
+    const openPaths = fs.readdirSync(fdRoot)
+      .map((entry) => {
+        try {
+          return fs.realpathSync(path.join(fdRoot, entry));
+        } catch {
+          return null;
+        }
+      })
+      .filter((entry) => typeof entry === "string")
+      .filter((entry) => entry.startsWith(rootPrefix));
+
+    return [...new Set(openPaths)];
+  } catch {
+    return [];
+  }
+}
+
+function selectLiveSessionCandidatePath(candidates, currentPath, captureSinceMs = null) {
+  const cwdMatches = candidates.filter((candidate) => candidate.cwd === currentPath);
+  if (cwdMatches.length === 0) {
+    return null;
+  }
+
+  const primary = cwdMatches.some((candidate) => candidate.isSubagent === false)
+    ? cwdMatches.filter((candidate) => candidate.isSubagent === false)
+    : cwdMatches;
+
+  const recent = Number.isFinite(captureSinceMs)
+    ? primary.filter((candidate) => Number.isFinite(candidate.mtimeMs) && candidate.mtimeMs >= captureSinceMs - SESSION_START_EARLY_TOLERANCE_MS)
+    : primary;
+  const ranked = (recent.length > 0 ? recent : primary)
+    .slice()
+    .sort((left, right) => right.mtimeMs - left.mtimeMs || right.startedAtMs - left.startedAtMs);
+
+  return ranked[0]?.path || null;
+}
+
+function readOpenSessionCandidates(pid, rootPath, reader) {
+  return listOpenFilePaths(pid, rootPath)
+    .map((filePath) => reader(filePath))
+    .filter((candidate) => candidate !== null);
+}
+
 function readCodexCandidate(filePath) {
   try {
     const [firstLine] = readFirstLines(filePath, 1);
@@ -143,6 +194,7 @@ function readCodexCandidate(filePath) {
     return {
       path: filePath,
       cwd: entry.payload.cwd,
+      isSubagent: Boolean(entry.payload?.source?.subagent),
       startedAtMs: Date.parse(entry.payload.timestamp),
       mtimeMs: fs.statSync(filePath).mtimeMs,
     };
@@ -151,7 +203,13 @@ function readCodexCandidate(filePath) {
   }
 }
 
-function selectCodexSessionFile(currentPath, processStartedAtMs) {
+function selectCodexSessionFile(currentPath, processStartedAtMs, options = {}) {
+  const liveCandidates = readOpenSessionCandidates(options.pid, CODEX_ROOT, readCodexCandidate);
+  const livePath = selectLiveSessionCandidatePath(liveCandidates, currentPath, options.captureSinceMs);
+  if (livePath) {
+    return livePath;
+  }
+
   const candidates = walkFiles(CODEX_ROOT, (filePath) => filePath.endsWith(".jsonl"))
     .map((filePath) => readCodexCandidate(filePath))
     .filter((candidate) => candidate !== null);
@@ -252,7 +310,13 @@ function readClaudeCandidate(filePath) {
   }
 }
 
-function selectClaudeSessionFile(currentPath, processStartedAtMs) {
+function selectClaudeSessionFile(currentPath, processStartedAtMs, options = {}) {
+  const liveCandidates = readOpenSessionCandidates(options.pid, CLAUDE_ROOT, readClaudeCandidate);
+  const livePath = selectLiveSessionCandidatePath(liveCandidates, currentPath, options.captureSinceMs);
+  if (livePath) {
+    return livePath;
+  }
+
   const candidates = walkFiles(CLAUDE_ROOT, (filePath) => filePath.endsWith(".jsonl"))
     .map((filePath) => readClaudeCandidate(filePath))
     .filter((candidate) => candidate !== null);
@@ -331,8 +395,15 @@ function readGeminiCandidate(filePath) {
   }
 }
 
-function selectGeminiSessionFile(currentPath, processStartedAtMs) {
+function selectGeminiSessionFile(currentPath, processStartedAtMs, options = {}) {
   const projectHash = createHash("sha256").update(currentPath).digest("hex");
+  const liveCandidates = readOpenSessionCandidates(options.pid, GEMINI_ROOT, readGeminiCandidate)
+    .filter((candidate) => candidate.projectHash === projectHash);
+  const livePath = selectLiveSessionCandidatePath(liveCandidates, projectHash, options.captureSinceMs);
+  if (livePath) {
+    return livePath;
+  }
+
   const candidates = walkFiles(GEMINI_ROOT, (filePath) => filePath.endsWith(".json"))
     .map((filePath) => readGeminiCandidate(filePath))
     .filter((candidate) => candidate !== null && candidate.projectHash === projectHash);
@@ -384,6 +455,7 @@ module.exports = {
   readClaudeAnswers,
   readCodexAnswers,
   readGeminiAnswers,
+  selectLiveSessionCandidatePath,
   selectSessionCandidatePath,
   selectClaudeSessionFile,
   selectCodexSessionFile,

package/src/cli.js

@@ -82,6 +82,9 @@ function renderSeatStatus(seat) {
   if (seat.partnerLive) {
     bits.push("peer live");
   }
+  if (seat.trust) {
+    bits.push(`trust ${seat.trust}`);
+  }
   if (seat.lastAnswerAt) {
     bits.push(`last answer ${seat.lastAnswerAt}`);
   }

package/src/runtime.js

@@ -23,11 +23,14 @@ const {
   getSessionPaths,
   hashText,
   isPidAlive,
+  loadOrCreateSeatIdentity,
   listSessionNames,
   readAppendedText,
   readJson,
   sanitizeRelayText,
+  signText,
   sleep,
+  verifyText,
   writeJson,
 } = require("./util");
 
@@ -142,23 +145,79 @@ function getChildProcesses(rootPid) {
   }
 }
 
-function resolveSessionFile(agentType, currentPath, processStartedAtMs) {
+function resolveSessionFile(agentType, agentPid, currentPath, captureSinceMs, processStartedAtMs) {
   if (!currentPath) {
     return null;
   }
 
+  const options = {
+    pid: agentPid,
+    captureSinceMs,
+  };
+
   if (agentType === "codex") {
-    return selectCodexSessionFile(currentPath, processStartedAtMs);
+    return selectCodexSessionFile(currentPath, processStartedAtMs, options);
   }
   if (agentType === "claude") {
-    return selectClaudeSessionFile(currentPath, processStartedAtMs);
+    return selectClaudeSessionFile(currentPath, processStartedAtMs, options);
   }
   if (agentType === "gemini") {
-    return selectGeminiSessionFile(currentPath, processStartedAtMs);
+    return selectGeminiSessionFile(currentPath, processStartedAtMs, options);
   }
   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",
+    sessionName,
+    challenge,
+    id: entry.id,
+    seatId: entry.seatId,
+    origin: entry.origin,
+    createdAt: entry.createdAt,
+    text: entry.text,
+  });
+}
+
+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,
+  };
+}
+
 async function sendTextAndEnter(child, text, shouldAbort = () => false) {
   const lines = String(text || "").replace(/\r/g, "").split("\n");
 
@@ -226,7 +285,14 @@ class ArmedSeat {
     this.stdinCleanup = null;
     this.resizeCleanup = null;
     this.forceKillTimer = null;
+    this.identity = null;
     this.recentInboundRelays = [];
+    this.trustState = {
+      challenge: null,
+      peerPublicKey: null,
+      phase: this.seatId === 1 ? "waiting_for_peer_signature" : "waiting_for_seat1_key",
+      pairedAt: null,
+    };
     this.liveState = {
       type: null,
       pid: null,
@@ -272,10 +338,177 @@ class ArmedSeat {
     });
   }
 
+  initializeTrustMaterial() {
+    this.identity = loadOrCreateSeatIdentity(this.paths);
+
+    if (this.seatId !== 1) {
+      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 (this.seatId === 1) {
+      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_seat1_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();
 
     const shell = resolveShell();
     const shellArgs = resolveShellArgs(shell);
@@ -294,7 +527,7 @@ class ArmedSeat {
 
     this.childPid = this.child.pid;
     this.writeMeta();
-    this.writeStatus({ state: "running" });
+    this.writeStatus({ state: "running", trust: this.trustState.phase });
 
     this.child.onData((data) => {
       fs.appendFileSync(this.paths.pipePath, data);
@@ -441,7 +674,7 @@ class ArmedSeat {
   async pullPartnerEvents() {
     const { nextOffset, text } = readAppendedText(this.partnerPaths.eventsPath, this.partnerOffset);
     this.partnerOffset = nextOffset;
-    if (!text.trim() || !this.child || this.stopped) {
+    if (!text.trim() || !this.child || this.stopped || !this.isPaired()) {
       return;
     }
 
@@ -453,7 +686,20 @@ class ArmedSeat {
       }
 
       const payload = sanitizeRelayText(entry.text);
-      if (!payload) {
+      const signaturePayload = buildAnswerSignaturePayload(this.sessionName, this.trustState.challenge, {
+        id: entry.id,
+        seatId: entry.seatId,
+        origin: entry.origin || "unknown",
+        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;
       }
 
@@ -570,7 +816,9 @@ class ArmedSeat {
     if (!this.liveState.sessionFile) {
       this.liveState.sessionFile = resolveSessionFile(
         detectedAgent.type,
+        detectedAgent.pid,
         currentPath,
+        this.liveState.captureSinceMs,
         detectedAgent.processStartedAtMs
       );
 
@@ -643,7 +891,7 @@ class ArmedSeat {
     }
 
     const payload = sanitizeRelayText(entry.text);
-    if (!payload) {
+    if (!payload || !this.identity || !this.trustState.challenge) {
       return;
     }
 
@@ -653,14 +901,21 @@ class ArmedSeat {
       return;
     }
 
-    appendJsonl(this.paths.eventsPath, {
+    const signedEntry = {
       id: entry.id || createId(12),
       type: "answer",
       seatId: this.seatId,
       origin: entry.origin || "unknown",
       text: payload,
       createdAt: entry.createdAt || new Date().toISOString(),
-    });
+      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.log(`[${this.seatId}] ${previewText(payload)}`);
   }
@@ -670,11 +925,13 @@ class ArmedSeat {
       this.writeStatus({
         state: "stopping",
         partnerLive: this.partnerIsLive(),
+        trust: this.trustState.phase,
       });
       this.requestStop("stop_requested");
       return;
     }
 
+    this.syncTrustState();
     await this.pullPartnerEvents();
     if (this.stopped || this.stopRequested()) {
       this.requestStop("stop_requested");
@@ -693,6 +950,8 @@ class ArmedSeat {
       log: live.log,
       lastAnswerAt: live.lastAnswerAt,
       partnerLive: this.partnerIsLive(),
+      trust: this.trustState.phase,
+      challengeReady: Boolean(this.trustState.challenge),
     });
   }
 
@@ -704,6 +963,11 @@ class ArmedSeat {
 
     this.log(`${BRAND} seat ${this.seatId} armed for ${this.sessionName}.`);
     this.log("Use this shell normally. Codex, Claude, and Gemini final answers relay automatically from their local session logs.");
+    if (this.seatId === 1) {
+      this.log("Seat 1 generated the session key and is waiting for seat 2 to sign it.");
+    } else {
+      this.log("Seat 2 will sign the session key from seat 1, then relay goes live.");
+    }
     this.log("Run `muuuuse status` or `muuuuse stop` from any terminal.");
 
     try {
@@ -797,6 +1061,7 @@ 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

@@ -1,4 +1,10 @@
-const { createHash, randomBytes } = require("node:crypto");
+const {
+  createHash,
+  generateKeyPairSync,
+  randomBytes,
+  sign: cryptoSign,
+  verify: cryptoVerify,
+} = require("node:crypto");
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
@@ -28,6 +34,13 @@ function writeJson(filePath, value) {
   fs.renameSync(tempPath, filePath);
 }
 
+function writeSecret(filePath, value, mode = 0o600) {
+  ensureDir(path.dirname(filePath));
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tempPath, String(value), { mode });
+  fs.renameSync(tempPath, filePath);
+}
+
 function readJson(filePath, fallback = null) {
   try {
     return JSON.parse(fs.readFileSync(filePath, "utf8"));
@@ -161,15 +174,63 @@ function getSeatDir(sessionName, seatId) {
 function getSeatPaths(sessionName, seatId) {
   const dir = getSeatDir(sessionName, seatId);
   return {
+    ackPath: path.join(dir, "ack.json"),
+    challengePath: path.join(dir, "challenge.json"),
+    claimPath: path.join(dir, "claim.json"),
     dir,
     daemonPath: path.join(dir, "daemon.json"),
     eventsPath: path.join(dir, "events.jsonl"),
+    privateKeyPath: path.join(dir, "id_ed25519"),
+    publicKeyPath: path.join(dir, "id_ed25519.pub"),
     metaPath: path.join(dir, "meta.json"),
     pipePath: path.join(dir, "pipe.log"),
     statusPath: path.join(dir, "status.json"),
   };
 }
 
+function loadOrCreateSeatIdentity(paths) {
+  try {
+    const privateKey = fs.readFileSync(paths.privateKeyPath, "utf8").trim();
+    const publicKey = fs.readFileSync(paths.publicKeyPath, "utf8").trim();
+    if (privateKey && publicKey) {
+      return { privateKey, publicKey };
+    }
+  } catch {
+    // generate below
+  }
+
+  const { privateKey, publicKey } = generateKeyPairSync("ed25519");
+  const privateKeyPem = privateKey.export({ format: "pem", type: "pkcs8" });
+  const publicKeyPem = publicKey.export({ format: "pem", type: "spki" });
+  writeSecret(paths.privateKeyPath, privateKeyPem);
+  writeSecret(paths.publicKeyPath, publicKeyPem, 0o644);
+  return {
+    privateKey: String(privateKeyPem).trim(),
+    publicKey: String(publicKeyPem).trim(),
+  };
+}
+
+function signText(text, privateKey) {
+  return cryptoSign(null, Buffer.from(String(text || ""), "utf8"), privateKey).toString("base64");
+}
+
+function verifyText(text, signature, publicKey) {
+  if (!signature || !publicKey) {
+    return false;
+  }
+
+  try {
+    return cryptoVerify(
+      null,
+      Buffer.from(String(text || ""), "utf8"),
+      publicKey,
+      Buffer.from(String(signature || ""), "base64")
+    );
+  } catch {
+    return false;
+  }
+}
+
 function listSessionNames() {
   const sessionsRoot = path.join(getStateRoot(), "sessions");
   try {
@@ -195,9 +256,10 @@ function usage() {
     "Flow:",
     "  1. Run `muuuuse 1` in terminal one.",
     "  2. Run `muuuuse 2` in terminal two.",
-    "  3. Use those armed shells normally.",
-    "  4. Codex, Claude, and Gemini final answers relay automatically from their local session logs.",
-    "  5. Run `muuuuse status` or `muuuuse stop` from any shell.",
+    "  3. Seat 1 generates the session key and seat 2 signs it automatically.",
+    "  4. Use those armed shells normally.",
+    "  5. Codex, Claude, and Gemini final answers relay automatically from their local session logs.",
+    "  6. Run `muuuuse status` or `muuuuse stop` from any shell.",
     "",
     "Notes:",
     "  - No tmux.",
@@ -215,6 +277,7 @@ module.exports = {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
+  loadOrCreateSeatIdentity,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,
@@ -224,7 +287,10 @@ module.exports = {
   readAppendedText,
   readJson,
   sanitizeRelayText,
+  signText,
   sleep,
   usage,
+  verifyText,
   writeJson,
+  writeSecret,
 };