muuuuse 1.4.2 → 2.1.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": "2.1.0",
   "description": "🔌Muuuuse arms two regular terminals and relays final answers between them.",
   "type": "commonjs",
   "bin": {

package/src/agents.js

@@ -12,9 +12,11 @@ const {
 } = require("./util");
 
 const CODEX_ROOT = path.join(os.homedir(), ".codex", "sessions");
+const CODEX_SNAPSHOT_ROOT = path.join(os.homedir(), ".codex", "shell_snapshots");
 const CLAUDE_ROOT = path.join(os.homedir(), ".claude", "projects");
 const GEMINI_ROOT = path.join(os.homedir(), ".gemini", "tmp");
 const SESSION_START_EARLY_TOLERANCE_MS = 2 * 1000;
+const STRICT_SINGLE_CANDIDATE_EARLY_TOLERANCE_MS = 250;
 
 function walkFiles(rootPath, predicate, results = []) {
   try {
@@ -51,7 +53,11 @@ function buildDetectedAgent(type, process) {
 }
 
 function detectAgent(processes) {
-  const ordered = [...processes].sort((left, right) => left.elapsedSeconds - right.elapsedSeconds);
+  const ordered = [...processes].sort((left, right) => (
+    (left.depth ?? Number.MAX_SAFE_INTEGER) - (right.depth ?? Number.MAX_SAFE_INTEGER) ||
+    right.elapsedSeconds - left.elapsedSeconds ||
+    left.pid - right.pid
+  ));
   for (const process of ordered) {
     if (commandMatches(process.args, "codex")) {
       return buildDetectedAgent("codex", process);
@@ -93,6 +99,33 @@ function readFirstLines(filePath, maxLines = 20) {
   }
 }
 
+function sortSessionCandidates(candidates) {
+  return candidates
+    .slice()
+    .sort((left, right) => {
+      const leftDiff = Number.isFinite(left.diffMs) ? left.diffMs : Number.MAX_SAFE_INTEGER;
+      const rightDiff = Number.isFinite(right.diffMs) ? right.diffMs : Number.MAX_SAFE_INTEGER;
+      return (
+        leftDiff - rightDiff ||
+        right.startedAtMs - left.startedAtMs ||
+        right.mtimeMs - left.mtimeMs ||
+        left.path.localeCompare(right.path)
+      );
+    });
+}
+
+function annotateSessionCandidates(candidates, processStartedAtMs) {
+  return candidates.map((candidate) => ({
+    ...candidate,
+    diffMs: Number.isFinite(processStartedAtMs) && Number.isFinite(candidate.startedAtMs)
+      ? Math.abs(candidate.startedAtMs - processStartedAtMs)
+      : Number.POSITIVE_INFINITY,
+    relativeStartMs: Number.isFinite(processStartedAtMs) && Number.isFinite(candidate.startedAtMs)
+      ? candidate.startedAtMs - processStartedAtMs
+      : Number.NaN,
+  }));
+}
+
 function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs) {
   const cwdMatches = candidates.filter((candidate) => candidate.cwd === currentPath);
   if (cwdMatches.length === 0) {
@@ -107,12 +140,7 @@ function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs)
     return null;
   }
 
-  const preciseMatches = cwdMatches
-    .map((candidate) => ({
-      ...candidate,
-      diffMs: Math.abs(candidate.startedAtMs - processStartedAtMs),
-      relativeStartMs: candidate.startedAtMs - processStartedAtMs,
-    }))
+  const preciseMatches = annotateSessionCandidates(cwdMatches, processStartedAtMs)
     .filter((candidate) => (
       Number.isFinite(candidate.diffMs) &&
       Number.isFinite(candidate.relativeStartMs) &&
@@ -128,6 +156,126 @@ function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs)
   return null;
 }
 
+function readCodexSeatClaim(sessionId) {
+  if (!sessionId) {
+    return null;
+  }
+
+  const snapshotPath = path.join(CODEX_SNAPSHOT_ROOT, `${sessionId}.sh`);
+  try {
+    const text = fs.readFileSync(snapshotPath, "utf8");
+    const seatMatch = text.match(/declare -x MUUUUSE_SEAT="([^"]+)"/);
+    const sessionMatch = text.match(/declare -x MUUUUSE_SESSION="([^"]+)"/);
+    if (!seatMatch || !sessionMatch) {
+      return null;
+    }
+
+    return {
+      seatId: seatMatch[1],
+      sessionName: sessionMatch[1],
+    };
+  } catch {
+    return null;
+  }
+}
+
+function selectClaimedCodexCandidatePath(candidates, options = {}) {
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  if (!seatId || !sessionName || candidates.length <= 1) {
+    return null;
+  }
+
+  const annotated = candidates.map((candidate) => ({
+    ...candidate,
+    claim: readCodexSeatClaim(candidate.sessionId),
+  }));
+
+  const exactMatches = annotated.filter((candidate) => (
+    candidate.claim?.seatId === seatId &&
+    candidate.claim?.sessionName === sessionName
+  ));
+  if (exactMatches.length === 1) {
+    return exactMatches[0].path;
+  }
+
+  const otherSeatClaims = annotated.filter((candidate) => (
+    candidate.claim?.sessionName === sessionName &&
+    candidate.claim?.seatId !== seatId
+  ));
+  if (otherSeatClaims.length === 0) {
+    return null;
+  }
+
+  const foreignPaths = new Set(otherSeatClaims.map((candidate) => candidate.path));
+  const remaining = annotated.filter((candidate) => !foreignPaths.has(candidate.path));
+  if (remaining.length === 1) {
+    return remaining[0].path;
+  }
+
+  return null;
+}
+
+function listOpenFilePathsForPids(pids, rootPath) {
+  const normalizedPids = [...new Set(
+    (Array.isArray(pids) ? pids : [pids])
+      .map((pid) => Number.parseInt(pid, 10))
+      .filter((pid) => Number.isInteger(pid) && pid > 0)
+  )];
+  if (normalizedPids.length === 0) {
+    return [];
+  }
+
+  const rootPrefix = path.resolve(rootPath);
+  const openPaths = new Set();
+
+  for (const pid of normalizedPids) {
+    const fdRoot = `/proc/${pid}/fd`;
+    try {
+      for (const entry of fs.readdirSync(fdRoot)) {
+        try {
+          const resolved = fs.realpathSync(path.join(fdRoot, entry));
+          if (typeof resolved === "string" && resolved.startsWith(rootPrefix)) {
+            openPaths.add(resolved);
+          }
+        } catch {
+          // Ignore descriptors that disappear while we are inspecting them.
+        }
+      }
+    } catch {
+      // Ignore pids that have already exited.
+    }
+  }
+
+  return [...openPaths];
+}
+
+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(pids, rootPath, reader) {
+  return listOpenFilePathsForPids(pids, rootPath)
+    .map((filePath) => reader(filePath))
+    .filter((candidate) => candidate !== null);
+}
+
 function readCodexCandidate(filePath) {
   try {
     const [firstLine] = readFirstLines(filePath, 1);
@@ -143,6 +291,8 @@ function readCodexCandidate(filePath) {
     return {
       path: filePath,
       cwd: entry.payload.cwd,
+      isSubagent: Boolean(entry.payload?.source?.subagent),
+      sessionId: entry.payload.id || null,
       startedAtMs: Date.parse(entry.payload.timestamp),
       mtimeMs: fs.statSync(filePath).mtimeMs,
     };
@@ -151,12 +301,143 @@ function readCodexCandidate(filePath) {
   }
 }
 
-function selectCodexSessionFile(currentPath, processStartedAtMs) {
+function rankCodexCandidates(candidates, processStartedAtMs) {
+  return sortSessionCandidates(annotateSessionCandidates(candidates, processStartedAtMs));
+}
+
+function selectExactClaimedCodexCandidate(candidates, options = {}, processStartedAtMs = null) {
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  if (!seatId || !sessionName) {
+    return null;
+  }
+
+  const exactMatches = rankCodexCandidates(
+    candidates.filter((candidate) => {
+      const claim = readCodexSeatClaim(candidate.sessionId);
+      return claim?.seatId === seatId && claim?.sessionName === sessionName;
+    }),
+    processStartedAtMs
+  );
+
+  return exactMatches[0]?.path || null;
+}
+
+function filterForeignClaimedCodexCandidates(candidates, options = {}) {
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  if (!seatId || !sessionName) {
+    return candidates.slice();
+  }
+
+  return candidates.filter((candidate) => {
+    const claim = readCodexSeatClaim(candidate.sessionId);
+    return !(claim?.sessionName === sessionName && claim?.seatId && claim.seatId !== seatId);
+  });
+}
+
+function selectStrictSingleCodexCandidatePath(candidates, processStartedAtMs) {
+  if (candidates.length !== 1 || !Number.isFinite(processStartedAtMs)) {
+    return null;
+  }
+
+  const [candidate] = annotateSessionCandidates(candidates, processStartedAtMs);
+  if (!Number.isFinite(candidate.relativeStartMs)) {
+    return null;
+  }
+
+  if (
+    candidate.relativeStartMs < -STRICT_SINGLE_CANDIDATE_EARLY_TOLERANCE_MS ||
+    candidate.relativeStartMs > SESSION_MATCH_WINDOW_MS
+  ) {
+    return null;
+  }
+
+  return candidate.path;
+}
+
+function selectCodexCandidatePath(candidates, currentPath, processStartedAtMs, options = {}) {
+  const cwdMatches = candidates.filter((candidate) => candidate.cwd === currentPath);
+  if (cwdMatches.length === 0) {
+    return null;
+  }
+
+  const seatId = options.seatId == null ? null : String(options.seatId);
+  const sessionName = typeof options.sessionName === "string" ? options.sessionName : null;
+  const exactClaimPath = selectExactClaimedCodexCandidate(cwdMatches, options, processStartedAtMs);
+  if (exactClaimPath) {
+    return exactClaimPath;
+  }
+
+  const foreignClaimsPresent = Boolean(
+    seatId &&
+    sessionName &&
+    cwdMatches.some((candidate) => {
+      const claim = readCodexSeatClaim(candidate.sessionId);
+      return claim?.sessionName === sessionName && claim?.seatId && claim.seatId !== seatId;
+    })
+  );
+  const allowedMatches = filterForeignClaimedCodexCandidates(cwdMatches, options);
+  if (allowedMatches.length === 0) {
+    return null;
+  }
+
+  if (!Number.isFinite(processStartedAtMs)) {
+    return allowedMatches.length === 1 ? allowedMatches[0].path : null;
+  }
+
+  const preciseMatches = rankCodexCandidates(
+    allowedMatches.filter((candidate) => {
+      const annotated = annotateSessionCandidates([candidate], processStartedAtMs)[0];
+      return (
+        Number.isFinite(annotated.diffMs) &&
+        Number.isFinite(annotated.relativeStartMs) &&
+        annotated.relativeStartMs >= -SESSION_START_EARLY_TOLERANCE_MS &&
+        annotated.relativeStartMs <= SESSION_MATCH_WINDOW_MS
+      );
+    }),
+    processStartedAtMs
+  );
+
+  const preciseClaimPath = selectClaimedCodexCandidatePath(preciseMatches, options);
+  if (preciseClaimPath) {
+    return preciseClaimPath;
+  }
+
+  const pairedSeatSelection = seatId && sessionName;
+  if (pairedSeatSelection && options.allowUnclaimedSingleCandidate === false && !foreignClaimsPresent) {
+    return null;
+  }
+
+  if (preciseMatches.length === 1) {
+    return selectStrictSingleCodexCandidatePath(preciseMatches, processStartedAtMs);
+  }
+
+  if (allowedMatches.length === 1) {
+    return selectStrictSingleCodexCandidatePath(allowedMatches, processStartedAtMs);
+  }
+
+  return null;
+}
+
+function selectCodexSessionFile(currentPath, processStartedAtMs, options = {}) {
+  const liveCandidates = readOpenSessionCandidates(options.pids ?? options.pid, CODEX_ROOT, readCodexCandidate);
+  const livePath = selectCodexCandidatePath(liveCandidates, currentPath, processStartedAtMs, {
+    ...options,
+    allowUnclaimedSingleCandidate: true,
+  });
+  if (livePath) {
+    return livePath;
+  }
+
   const candidates = walkFiles(CODEX_ROOT, (filePath) => filePath.endsWith(".jsonl"))
     .map((filePath) => readCodexCandidate(filePath))
     .filter((candidate) => candidate !== null);
 
-  return selectSessionCandidatePath(candidates, currentPath, processStartedAtMs);
+  return selectCodexCandidatePath(candidates, currentPath, processStartedAtMs, {
+    ...options,
+    allowUnclaimedSingleCandidate: false,
+  });
 }
 
 function extractCodexAssistantText(content) {
@@ -252,7 +533,13 @@ function readClaudeCandidate(filePath) {
   }
 }
 
-function selectClaudeSessionFile(currentPath, processStartedAtMs) {
+function selectClaudeSessionFile(currentPath, processStartedAtMs, options = {}) {
+  const liveCandidates = readOpenSessionCandidates(options.pids ?? 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 +618,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.pids ?? 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 +678,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}`);
   }