@triflux/remote 10.52.0 → 10.53.0

package/hub/team/claude-transcript.mjs

@@ -157,6 +157,25 @@ function acceptLine(state, line, marker) {
   }
 }
 
+// daemon 과 tmux wait 가 같은 기준으로 끝을 판정한다. 아직이면 null.
+export function claudeWaitVerdict(transcript, idle) {
+  if (transcript?.error)
+    return { ok: false, status: "failed", error: transcript.error };
+  if (
+    !transcript?.userSeen ||
+    !transcript.turnEnded ||
+    !(idle || transcript.sectionClosed)
+  )
+    return null;
+  if (!transcript.response.trim())
+    return {
+      ok: false,
+      status: "failed",
+      error: "turn ended without assistant text",
+    };
+  return { status: "completed", done: true };
+}
+
 export async function readClaudeTranscript(transcriptPath, { requestId } = {}) {
   if (!transcriptPath) return null;
   const marker = requestId ? `[tfx-live req=${requestId}]` : null;

package/hub/team/cli/commands/start/start-headless.mjs

@@ -173,6 +173,8 @@ export async function startHeadlessTeam({
     console.log(
       `=== HEADLESS_COMPLETE succeeded=${succeeded.length} failed=${failed.length} total=${results.length} ===`,
     );
+    if (handle.resultsIndexPath)
+      console.log(`  ${DIM}결과 색인: ${handle.resultsIndexPath}${RESET}`);
 
     if (failed.length > 0) {
       for (const r of failed)

package/hub/team/headless.mjs

@@ -43,6 +43,7 @@ import {
   startCapture,
   waitForCompletion,
 } from "./psmux.mjs";
+import { createResultsIndex, resultsIndexPath } from "./results-index.mjs";
 import { createLogDashboard } from "./tui.mjs";
 import { createWtManager } from "./wt-manager.mjs";
 
@@ -126,6 +127,14 @@ export function normalizeHeadlessRole(role) {
   return normalized && VALID_ROUTE_AGENTS.has(normalized) ? normalized : "";
 }
 
+export function headlessResultFile(sessionName, paneName) {
+  return join(RESULT_DIR, `${sessionName}-${paneName}.txt`).replace(/\\/g, "/");
+}
+
+export function headlessResultsIndexPath(sessionName) {
+  return resultsIndexPath(RESULT_DIR, sessionName).replace(/\\/g, "/");
+}
+
 export function resolveHeadlessDisplayName(assignment = {}, paneName = "") {
   const normalized = String(assignment.displayName || "")
     .trim()
@@ -543,10 +552,7 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
       });
 
     // 캡처 시작 + 컬러 배너 + 명령 dispatch
-    const resultFile = join(
-      RESULT_DIR,
-      `${sessionName}-${paneName}.txt`,
-    ).replace(/\\/g, "/");
+    const resultFile = headlessResultFile(sessionName, paneName);
     // Issue #118 review R1 HIGH: stale artifact 제거 (이전 run / restart 잔재)
     cleanStaleResultArtifacts(resultFile);
     const cmd = buildHeadlessCommand(
@@ -634,10 +640,7 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
       const displayName = resolveHeadlessDisplayName(assignment, paneName);
       const workerId = getHeadlessWorkerAgentId(sessionName, i);
       const resolvedCli = resolveCliType(assignment.cli);
-      const resultFile = join(
-        RESULT_DIR,
-        `${sessionName}-${paneName}.txt`,
-      ).replace(/\\/g, "/");
+      const resultFile = headlessResultFile(sessionName, paneName);
       // Issue #118 review R1 HIGH: stale artifact 제거 (이전 run / restart 잔재)
       cleanStaleResultArtifacts(resultFile);
       const cmd = buildHeadlessCommand(
@@ -918,6 +921,23 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     return { sessionName, results: [], sessionOwnership, agentsRows };
   }
 
+  const resultsIndex = createResultsIndex(
+    headlessResultsIndexPath(sessionName),
+    sessionName,
+    normalizedAssignments.map((a, i) => {
+      const paneName = `worker-${i + 1}`;
+      return {
+        paneName,
+        displayName: a.displayName,
+        cli: resolveCliType(a.cli),
+        role: a.role,
+        resultFile: headlessResultFile(sessionName, paneName),
+      };
+    }),
+    // 같은 이름의 남의 세션 색인을 덮어쓰지 않도록 세션을 소유한 동안만 쓴다.
+    () => sessionOwnership.owned,
+  );
+
   let runCompleted = false;
   let completedResults = [];
   let runFailed = false;
@@ -996,6 +1016,11 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
 
   // onProgress 예외를 삼켜 실행 흐름 보호 (onPoll과 동일 패턴)
   const combinedProgress = (event) => {
+    if (event.type === "session_created") resultsIndex.begin();
+    else if (event.type === "dispatched")
+      resultsIndex.workerStarted(event.paneName);
+    else if (event.type === "completed")
+      resultsIndex.workerFinished(event.paneName, event);
     feedTui(event);
     if (onProgress) {
       try {
@@ -1077,6 +1102,7 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
     runFailed = true;
     runError = error;
   }
+  resultsIndex.finish(runCompleted);
 
   if (!runCompleted) {
     sessionOwnership.release();
@@ -1086,6 +1112,7 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
   return {
     sessionName,
     results: completedResults,
+    resultsIndexPath: resultsIndex.path,
     sessionOwnership,
     agentsRows,
   };
@@ -1638,6 +1665,7 @@ export async function runHeadlessInteractive(
   const handle = {
     sessionName,
     results,
+    resultsIndexPath: runResult.resultsIndexPath,
     dispatches,
     _killed: false,
 

package/hub/team/results-index.mjs

@@ -0,0 +1,92 @@
+// headless 세션 결과 색인. 화면의 HEADLESS_COMPLETE 문자열 대신 읽도록 세션당 JSON 하나를 둔다 (ADR-0034).
+import { renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const RESULTS_INDEX_VERSION = 1;
+
+export function resultsIndexPath(dir, sessionName) {
+  return join(dir, `${sessionName}.results.json`);
+}
+
+/**
+ * @param {string} path
+ * @param {string} sessionName
+ * @param {Array<{paneName: string, displayName?: string, cli: string, role?: string, resultFile: string}>} workers
+ * @param {() => boolean} canWrite
+ */
+export function createResultsIndex(path, sessionName, workers, canWrite) {
+  const now = () => new Date().toISOString();
+  const index = {
+    version: RESULTS_INDEX_VERSION,
+    sessionName,
+    startedAt: now(),
+    finishedAt: null,
+    completed: false,
+    workers: workers.map((w) => ({
+      paneName: w.paneName,
+      displayName: w.displayName || w.paneName,
+      cli: w.cli,
+      role: w.role || "",
+      status: "pending",
+      matched: null,
+      exitCode: null,
+      sessionDead: false,
+      startedAt: null,
+      finishedAt: null,
+      resultFile: w.resultFile,
+    })),
+  };
+  const byPane = new Map(index.workers.map((w) => [w.paneName, w]));
+
+  // 임시 파일에 쓰고 rename 해 읽는 쪽이 반쯤 쓴 JSON 을 보지 않게 한다.
+  // 색인은 보조 산출물이라 쓰기 실패가 실행을 멈추면 안 된다.
+  const flush = () => {
+    if (!canWrite()) return;
+    const tmp = `${path}.${process.pid}.tmp`;
+    try {
+      writeFileSync(tmp, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+      renameSync(tmp, path);
+    } catch {
+      try {
+        rmSync(tmp, { force: true });
+      } catch {
+        /* best-effort */
+      }
+    }
+  };
+
+  return {
+    path,
+    // 같은 이름의 이전 실행 색인이 남아 있으면 세션을 잡자마자 덮어 오판을 막는다.
+    begin: flush,
+    workerStarted(paneName) {
+      const w = byPane.get(paneName);
+      if (!w || w.status !== "pending") return;
+      w.status = "running";
+      w.startedAt = now();
+      flush();
+    },
+    workerFinished(paneName, { matched, exitCode, sessionDead } = {}) {
+      const w = byPane.get(paneName);
+      if (!w) return;
+      w.status = matched && exitCode === 0 ? "completed" : "failed";
+      w.matched = Boolean(matched);
+      w.exitCode = exitCode ?? null;
+      w.sessionDead = Boolean(sessionDead);
+      w.finishedAt = now();
+      flush();
+    },
+    finish(completed) {
+      // 예외로 끝나면 끝나지 못한 워커를 failed 로 확정해 "아직 도는 중"과 구분한다.
+      for (const w of index.workers) {
+        if (w.status === "pending" || w.status === "running") {
+          w.status = "failed";
+          w.finishedAt = now();
+        }
+      }
+      index.finishedAt = now();
+      index.completed = Boolean(completed);
+      flush();
+    },
+  };
+}

package/hub/team/uds-orchestrator.mjs

@@ -15,12 +15,12 @@ function codexClient(socketPath, timeoutMs, clientFactory) {
   return clientFactory({ socketPath, connectTimeoutMs: timeoutMs });
 }
 
-async function initializeCodexClient(client, timeoutMs) {
+async function initializeCodexClient(client, timeoutMs, remainingMs) {
   await client.connect();
   await client.request(
     "initialize",
     { clientInfo: { name: "triflux-tfx-live", version: "1.0.0" } },
-    timeoutMs,
+    remainingMs ? Math.max(1, remainingMs()) : timeoutMs,
   );
   client.notify("initialized", {});
 }
@@ -211,7 +211,14 @@ async function normalizedCwd(cwd) {
   }
 }
 
-async function loadedCodexThreads(client, cwd, timeoutMs) {
+// timeoutMs 는 RPC 하나의 상한이다. remainingMs 를 주면 조회 전체가 그 안에 끝나야 한다.
+async function loadedCodexThreads(client, cwd, timeoutMs, remainingMs) {
+  const limit = () => {
+    if (!remainingMs) return timeoutMs;
+    const left = remainingMs();
+    if (left <= 0) throw new Error("codex thread listing timed out");
+    return left;
+  };
   const wantedCwd = await normalizedCwd(cwd);
   const threads = [];
   let cursor;
@@ -219,10 +226,10 @@ async function loadedCodexThreads(client, cwd, timeoutMs) {
     const result = await client.request(
       "thread/loaded/list",
       cursor ? { cursor } : {},
-      timeoutMs,
+      limit(),
     );
     for (const threadId of result?.data || []) {
-      const thread = await readCodexThread(client, threadId, timeoutMs);
+      const thread = await readCodexThread(client, threadId, limit());
       if (wantedCwd && (await normalizedCwd(thread.cwd)) !== wantedCwd)
         continue;
       threads.push({
@@ -241,23 +248,15 @@ async function loadedCodexThreads(client, cwd, timeoutMs) {
 export async function listCodexAppServerThreads({
   socketPath,
   cwd,
+  timeoutMs = DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
   clientFactory = (opts) => new JsonRpcWsUdsClient(opts),
 } = {}) {
-  const client = codexClient(
-    socketPath,
-    DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
-    clientFactory,
-  );
+  const deadline = Date.now() + timeoutMs;
+  const remainingMs = () => deadline - Date.now();
+  const client = codexClient(socketPath, timeoutMs, clientFactory);
   try {
-    await initializeCodexClient(
-      client,
-      DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
-    );
-    return await loadedCodexThreads(
-      client,
-      cwd,
-      DEFAULT_CODEX_APP_SERVER_UDS_BOOTSTRAP_MS,
-    );
+    await initializeCodexClient(client, timeoutMs, remainingMs);
+    return await loadedCodexThreads(client, cwd, timeoutMs, remainingMs);
   } finally {
     client.close();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triflux/remote",
-  "version": "10.52.0",
+  "version": "10.53.0",
   "description": "triflux remote — team mode, psmux, MCP workers.",
   "type": "module",
   "main": "hub/index.mjs",

package/scripts/lib/mcp-guard-engine.mjs

@@ -40,7 +40,6 @@ const DEFAULT_REGISTRY = Object.freeze({
     unknown_server_action: "warn",
     sync_denylist: [],
     watched_paths: [
-      "~/.gemini/settings.json",
       "~/.codex/config.toml",
       "~/.claude.json",
       "~/.claude/settings.json",
@@ -709,7 +708,7 @@ function serverTargets(serverConfig) {
       ),
     ];
   }
-  return ["claude", "gemini", "codex", "antigravity"];
+  return ["claude", "codex", "antigravity"];
 }
 
 function serverAppliesToClient(serverConfig, client) {
@@ -1718,7 +1717,7 @@ export function addRegistryServer(name, url, options = {}) {
                 .filter(Boolean),
             ),
           ]
-        : ["claude", "gemini", "codex", "antigravity"],
+        : ["claude", "codex", "antigravity"],
     description: options.description || `${trimmedName} MCP 서버`,
   };