muuuuse 3.3.6 → 3.3.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muuuuse",
-  "version": "3.3.6",
+  "version": "3.3.8",
   "description": "🔌Muuuuse arms regular terminals and relays assistant output across signed terminal links.",
   "type": "commonjs",
   "bin": {

package/src/agents.js

@@ -716,10 +716,20 @@ function readGeminiCandidate(filePath) {
   }
 }
 
-function selectGeminiSessionFile(currentPath, processStartedAtMs, options = {}) {
+function rankGeminiCandidates(candidates) {
+  return candidates
+    .slice()
+    .sort((left, right) => (
+      (right.lastUpdatedMs || right.mtimeMs || 0) - (left.lastUpdatedMs || left.mtimeMs || 0) ||
+      (right.mtimeMs || 0) - (left.mtimeMs || 0) ||
+      (right.startedAtMs || 0) - (left.startedAtMs || 0) ||
+      left.path.localeCompare(right.path)
+    ));
+}
+
+function selectGeminiSessionFileFromRoots(currentPath, processStartedAtMs, roots, options = {}, fallbackMode = "strict") {
   const projectHash = createHash("sha256").update(currentPath).digest("hex");
-  const geminiRoots = getGeminiRoots(currentPath, options);
-  const liveCandidates = geminiRoots
+  const liveCandidates = roots
     .flatMap((rootPath) => readOpenSessionCandidates(options.pids ?? options.pid, rootPath, readGeminiCandidate))
     .filter((candidate) => candidate.projectHash === projectHash);
   const livePath = selectLiveSessionCandidatePath(liveCandidates, projectHash, options.captureSinceMs);
@@ -727,41 +737,91 @@ function selectGeminiSessionFile(currentPath, processStartedAtMs, options = {})
     return livePath;
   }
 
-  const candidates = geminiRoots
+  const candidates = roots
     .flatMap((rootPath) => walkFiles(rootPath, (filePath) => filePath.endsWith(".json")))
     .map((filePath) => readGeminiCandidate(filePath))
     .filter((candidate) => candidate !== null && candidate.projectHash === projectHash);
 
+  if (fallbackMode === "latest") {
+    return rankGeminiCandidates(candidates)[0]?.path || null;
+  }
+
   return selectSessionCandidatePath(candidates, projectHash, processStartedAtMs);
 }
 
-function readGeminiAnswers(filePath, lastMessageId = null, sinceMs = null) {
+function selectGeminiSessionFile(currentPath, processStartedAtMs, options = {}) {
+  const geminiRoots = getGeminiRoots(currentPath, options);
+  const seatId = Number.parseInt(String(options.seatId || "").trim(), 10);
+
+  if (Number.isInteger(seatId) && seatId > 0 && geminiRoots.length > 0) {
+    const seatLocalPath = selectGeminiSessionFileFromRoots(
+      currentPath,
+      processStartedAtMs,
+      [geminiRoots[0]],
+      options,
+      "latest"
+    );
+    if (seatLocalPath) {
+      return seatLocalPath;
+    }
+  }
+
+  const fallbackRoots = Number.isInteger(seatId) && seatId > 0
+    ? geminiRoots.slice(1)
+    : geminiRoots;
+  return selectGeminiSessionFileFromRoots(currentPath, processStartedAtMs, fallbackRoots, options);
+}
+
+function parseGeminiMessage(message, options = {}) {
+  const flowMode = options.flowMode === true;
+  if (!message || message.type !== "gemini" || typeof message.content !== "string") {
+    return null;
+  }
+
+  const text = sanitizeRelayText(message.content);
+  if (!text) {
+    return null;
+  }
+
+  const toolCalls = Array.isArray(message.toolCalls) ? message.toolCalls : [];
+  const phase = toolCalls.length > 0 ? "commentary" : "final_answer";
+  if (phase === "commentary" && !flowMode) {
+    return null;
+  }
+
+  return {
+    id: message.id || hashText(JSON.stringify(message)),
+    text,
+    phase,
+    timestamp: message.timestamp || new Date().toISOString(),
+  };
+}
+
+function readGeminiAnswers(filePath, lastMessageId = null, sinceMs = null, options = {}) {
   try {
     const entry = JSON.parse(fs.readFileSync(filePath, "utf8"));
     const messages = Array.isArray(entry.messages) ? entry.messages : [];
-    const finalMessages = messages.filter((message) => {
-      const toolCalls = Array.isArray(message.toolCalls) ? message.toolCalls : [];
-      return message.type === "gemini" && typeof message.content === "string" && message.content.trim() && toolCalls.length === 0;
-    });
 
     let startIndex = 0;
     if (lastMessageId) {
-      const previousIndex = finalMessages.findIndex((message) => message.id === lastMessageId);
-      startIndex = previousIndex === -1 ? finalMessages.length : previousIndex + 1;
+      const previousIndex = messages.findIndex((message) => message?.id === lastMessageId);
+      startIndex = previousIndex === -1 ? 0 : previousIndex + 1;
     }
 
-    const answers = finalMessages.slice(startIndex).map((message) => ({
-      id: message.id || hashText(JSON.stringify(message)),
-      text: sanitizeRelayText(message.content),
-      phase: "final_answer",
-      timestamp: message.timestamp || entry.lastUpdated || new Date().toISOString(),
-    }));
+    const answers = messages
+      .slice(startIndex)
+      .map((message) => parseGeminiMessage(message, options))
+      .filter((answer) => answer !== null);
+
+    const lastSeenMessage = [...messages]
+      .reverse()
+      .find((message) => typeof message?.id === "string" && message.id.trim());
 
     return {
       answers: answers
         .filter((answer) => answer.text.length > 0)
         .filter((answer) => isAnswerNewEnough(answer, sinceMs)),
-      lastMessageId: finalMessages.length > 0 ? finalMessages[finalMessages.length - 1].id : lastMessageId,
+      lastMessageId: lastSeenMessage?.id || lastMessageId,
       fileSize: getFileSize(filePath),
     };
   } catch {