triflux 10.9.16 → 10.9.18

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "triflux",
       "description": "Tri-CLI orchestrator for Claude Code. Routes tasks across Claude + Codex + Gemini with consensus intelligence, natural language routing, 42 skills, and cross-model review.",
-      "version": "10.9.6",
+      "version": "10.9.18",
       "author": {
         "name": "tellang"
       },
@@ -30,5 +30,5 @@
       ]
     }
   ],
-  "version": "10.9.14"
+  "version": "10.9.18"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "10.3.4",
+  "version": "10.9.17",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "author": {
     "name": "tellang"

package/hub/lib/spawn-trace.mjs

@@ -331,6 +331,10 @@ function normalizeExecFileArgs(args, options, callback) {
   };
 }
 
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 export function spawn(command, args, options) {
   const { argsList, options: normalizedOptions } = normalizeSpawnArgs(
     args,
@@ -369,6 +373,32 @@ export function spawn(command, args, options) {
   });
 }
 
+export async function spawnWithBackoff(command, args, options, maxRetries = 1) {
+  const retryLimit =
+    Number.isInteger(maxRetries) && maxRetries >= 0 ? maxRetries : 1;
+  let originalRateLimitError = null;
+
+  for (let attempt = 0; attempt <= retryLimit; attempt += 1) {
+    try {
+      return spawn(command, args, options);
+    } catch (error) {
+      if (error?.reasonCode !== "rate_limit") {
+        throw error;
+      }
+
+      originalRateLimitError ??= error;
+
+      if (attempt >= retryLimit) {
+        throw originalRateLimitError;
+      }
+
+      await wait(RATE_WINDOW_MS);
+    }
+  }
+
+  throw originalRateLimitError;
+}
+
 export function execFile(file, args, options, callback) {
   const normalized = normalizeExecFileArgs(args, options, callback);
   const traceId = nextTraceId();
@@ -515,6 +545,7 @@ export const spawnSync = childProcess.spawnSync;
 export default {
   ...childProcess,
   spawn,
+  spawnWithBackoff,
   execFile,
   execFileSync,
   get MAX_SPAWN_PER_SEC() {

package/hub/server.mjs

@@ -719,6 +719,11 @@ export async function startHub({
           pipe: pipe.getStatus(),
           assign_callback_pipe_path: assignCallbacks.path,
           assign_callback_pipe: assignCallbacks.getStatus(),
+          spawn_trace: {
+            max_per_sec: spawnTrace.getMaxSpawnPerSec(),
+            max_total_descendants: spawnTrace.MAX_TOTAL_DESCENDANTS,
+          },
+          version,
         });
       }
 

package/hub/team/backend.mjs

@@ -41,7 +41,7 @@ export class GeminiBackend {
   }
 
   buildArgs(prompt, resultFile, opts = {}) {
-    return `gemini --prompt ${prompt} --output-format text > '${resultFile}' 2>'${resultFile}.err'`;
+    return `$null | gemini --prompt ${prompt} --output-format text > '${resultFile}' 2>'${resultFile}.err'`;
   }
 
   env() {

package/hub/team/handoff.mjs

@@ -219,6 +219,14 @@ export function validateHandoff(parsed, context = {}) {
     );
   }
 
+  const filesChangedCount = Array.isArray(h.files_changed)
+    ? h.files_changed.filter(Boolean).length
+    : 0;
+  if (filesChangedCount === 0 && h.lead_action === "accept") {
+    h.lead_action = "needs_read";
+    warnings.push("files_changed empty: accept → needs_read");
+  }
+
   const missingCore = coreRequired.filter((f) => !h[f]);
   const missingRouting = routingRequired.filter((f) => !h[f]);
   const valid = missingCore.length === 0 && missingRouting.length === 0;
@@ -231,15 +239,20 @@ export function validateHandoff(parsed, context = {}) {
  * @param {number} exitCode
  * @param {string} resultFile
  * @param {string} [cli]
+ * @param {object} [context]
+ * @param {string[]} [context.filesChanged]
  * @returns {object}
  */
-export function buildFallbackHandoff(exitCode, resultFile, cli) {
+export function buildFallbackHandoff(exitCode, resultFile, cli, context = {}) {
   const ok = exitCode === 0;
+  const filesChanged = Array.isArray(context.filesChanged)
+    ? context.filesChanged.filter(Boolean)
+    : [];
   return {
     status: ok ? "ok" : "failed",
-    lead_action: ok ? "accept" : "retry",
+    lead_action: ok && filesChanged.length > 0 ? "accept" : ok ? "needs_read" : "retry",
     task: "unknown",
-    files_changed: [],
+    files_changed: filesChanged,
     verdict: `${cli || "worker"} completed (exit ${exitCode})`,
     confidence: "low",
     risk: "low",
@@ -298,6 +311,7 @@ export function processHandoff(rawText, context = {}) {
       context.exitCode ?? 1,
       context.resultFile || "none",
       context.cli,
+      { filesChanged: context.gitDiffFiles },
     );
     return {
       handoff: fb,

package/hub/team/headless.mjs

@@ -18,10 +18,15 @@ import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { requestJson } from "../bridge.mjs";
+import { getMaxSpawnPerSec } from "../lib/spawn-trace.mjs";
 import { escapePwshSingleQuoted } from "../cli-adapter-base.mjs";
 import { getBackend } from "./backend.mjs";
 import { resolveDashboardLayout } from "./dashboard-layout.mjs";
-import { HANDOFF_INSTRUCTION_SHORT, processHandoff } from "./handoff.mjs";
+import {
+  formatHandoffForLead,
+  HANDOFF_INSTRUCTION_SHORT,
+  processHandoff,
+} from "./handoff.mjs";
 import {
   capturePsmuxPane,
   createPsmuxSession,
@@ -316,7 +321,7 @@ export function createStallMonitor(paneId, resultFile, config, deps = {}) {
  * @param {string} [opts.command] — re-dispatch용 원본 명령
  * @param {string} [opts.token] — completion token
  * @param {(snapshot: string) => void} [opts.onPoll] — 폴링 콜백
- * @returns {Promise<{ matched: boolean, exitCode: number|null, restarts: number, stallDetected: boolean }>}
+ * @returns {Promise<{ matched: boolean, exitCode: number|null, restarts: number, stallDetected: boolean, paneId: string, token?: string, logPath?: string|null }>}
  */
 export async function waitForCompletionWithStallDetect(
   sessionName,
@@ -346,19 +351,23 @@ export async function waitForCompletionWithStallDetect(
   const _startCapture = deps.startCapture || startCapture;
 
   const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const completionPatterns = [
-    token
-      ? `${esc("__TRIFLUX_DONE__:")}${esc(token)}:(\\d+)`
-      : `${esc("__TRIFLUX_DONE__:")}\\S+:(\\d+)`,
-    token
-      ? `${esc("TFX_DONE_")}${esc(token)}:(\\d+)`
-      : `${esc("TFX_DONE_")}\\S+:(\\d+)`,
-  ];
-  const completionRe = new RegExp(completionPatterns.join("|"), "m");
+  const buildCompletionRegex = (activeToken) => {
+    const completionPatterns = [
+      activeToken
+        ? `${esc("__TRIFLUX_DONE__:")}${esc(activeToken)}:(\\d+)`
+        : `${esc("__TRIFLUX_DONE__:")}\\S+:(\\d+)`,
+      activeToken
+        ? `${esc("TFX_DONE_")}${esc(activeToken)}:(\\d+)`
+        : `${esc("TFX_DONE_")}\\S+:(\\d+)`,
+    ];
+    return new RegExp(completionPatterns.join("|"), "m");
+  };
 
   let restarts = 0;
   let currentPaneId = paneId;
   let stallDetected = false;
+  let currentToken = token;
+  let currentLogPath = opts.logPath || null;
 
   while (true) {
     let lastOutput = "";
@@ -385,6 +394,9 @@ export async function waitForCompletionWithStallDetect(
           restarts,
           stallDetected,
           timedOut: true,
+          paneId: currentPaneId,
+          token: currentToken,
+          logPath: currentLogPath,
         };
       }
 
@@ -399,6 +411,7 @@ export async function waitForCompletionWithStallDetect(
       }
 
       // 2) completion 토큰 감지
+      const completionRe = buildCompletionRegex(currentToken);
       const completionMatch = completionRe.exec(currentOutput);
       if (completionMatch) {
         return {
@@ -410,6 +423,9 @@ export async function waitForCompletionWithStallDetect(
           restarts,
           stallDetected,
           timedOut: false,
+          paneId: currentPaneId,
+          token: currentToken,
+          logPath: currentLogPath,
         };
       }
 
@@ -442,6 +458,9 @@ export async function waitForCompletionWithStallDetect(
               restarts,
               stallDetected,
               timedOut: false,
+              paneId: currentPaneId,
+              token: currentToken,
+              logPath: currentLogPath,
             };
           }
         } catch {
@@ -480,8 +499,10 @@ export async function waitForCompletionWithStallDetect(
             "#{session_name}:#{window_index}.#{pane_index}",
           ]);
           _startCapture(sessionName, newPaneId);
-          _dispatch(sessionName, newPaneId, command);
-          currentPaneId = newPaneId;
+          const redispatch = _dispatch(sessionName, newPaneId, command);
+          currentPaneId = redispatch?.paneId || newPaneId;
+          if (redispatch?.token) currentToken = redispatch.token;
+          if (redispatch?.logPath) currentLogPath = redispatch.logPath;
         }
 
         restarts++;
@@ -564,7 +585,11 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
       assignment.cli,
       assignment.prompt,
       resultFile,
-      { mcp: assignment.mcp, model: assignment.model },
+      {
+        mcp: assignment.mcp,
+        model: assignment.model,
+        cwd: assignment.cwd || assignment.workdir,
+      },
     );
     startCapture(sessionName, newPaneId);
     // pane 간 pipe-pane EBUSY 방지 — 이벤트 루프 해방하며 순차 대기
@@ -584,6 +609,7 @@ async function dispatchProgressive(sessionName, assignments, opts = {}) {
       role: assignment.role,
       command: cmd,
       workerId,
+      cwd: assignment.cwd || assignment.workdir,
     });
   }
 
@@ -635,7 +661,11 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
         assignment.cli,
         assignment.prompt,
         resultFile,
-        { mcp: assignment.mcp, model: assignment.model },
+        {
+          mcp: assignment.mcp,
+          model: assignment.model,
+          cwd: assignment.cwd || assignment.workdir,
+        },
       );
       const scriptDir = join(RESULT_DIR, sessionName);
       await registerHeadlessWorker(sessionName, i, assignment.cli);
@@ -660,6 +690,7 @@ async function dispatchBatch(sessionName, assignments, opts = {}) {
         role: assignment.role,
         command: cmd,
         workerId,
+        cwd: assignment.cwd || assignment.workdir,
       };
     }),
   );
@@ -739,6 +770,9 @@ async function awaitAll(
               onPoll: stallPollCb,
             },
           );
+          if (stallResult.paneId) d.paneId = stallResult.paneId;
+          if (stallResult.token) d.token = stallResult.token;
+          if (stallResult.logPath) d.logPath = stallResult.logPath;
           completion = {
             matched: stallResult.matched,
             exitCode: stallResult.exitCode,
@@ -798,28 +832,27 @@ async function awaitAll(
  * @returns {Array}
  */
 async function collectResults(sessionName, results) {
-  // B3 fix: git diff를 루프 밖에서 1회만 실행 (워커 수만큼 중복 방지)
-  let gitDiffFiles;
-  try {
-    const diffOut = execSync("git diff --name-only HEAD", {
-      encoding: "utf8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    gitDiffFiles = diffOut.trim().split("\n").filter(Boolean);
-  } catch {
-    /* git 미설치 또는 non-repo — 무시 */
-  }
-
   // handoff 파이프라인: parse → validate → format (각 워커 결과에 적용)
   return await Promise.all(
     results.map(async ({ d, completion, output }) => {
+      const workerGitDiffFiles = collectGitDiffFiles(d.cwd);
       const handoffResult = processHandoff(output, {
         exitCode: completion.exitCode,
         resultFile: d.resultFile,
         cli: d.cli,
-        gitDiffFiles,
+        gitDiffFiles: workerGitDiffFiles,
       });
+      if (
+        completion.exitCode === 0 &&
+        workerGitDiffFiles.length === 0 &&
+        handoffResult.handoff?.lead_action === "accept"
+      ) {
+        handoffResult.handoff = {
+          ...handoffResult.handoff,
+          lead_action: "needs_read",
+        };
+        handoffResult.formatted = formatHandoffForLead(handoffResult.handoff);
+      }
       const status =
         handoffResult.handoff?.status ||
         (completion.matched && completion.exitCode === 0
@@ -842,6 +875,7 @@ async function collectResults(sessionName, results) {
         exitCode: completion.exitCode,
         output,
         resultFile: d.resultFile,
+        workerGitDiffFiles,
         sessionDead: completion.sessionDead || false,
         handoff: handoffResult.handoff,
         handoffFormatted: handoffResult.formatted,
@@ -852,6 +886,20 @@ async function collectResults(sessionName, results) {
   );
 }
 
+function collectGitDiffFiles(cwd) {
+  try {
+    const diffOut = execSync("git diff --name-only HEAD", {
+      cwd,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return diffOut.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
 /**
  * 헤드리스 CLI 오케스트레이션 실행
  *
@@ -880,6 +928,19 @@ export async function runHeadless(sessionName, assignments, opts = {}) {
 
   mkdirSync(RESULT_DIR, { recursive: true });
 
+  // Hub version skew pre-flight (fail-open, best-effort)
+  requestJson("/status", { method: "GET", timeoutMs: 500 })
+    .then((status) => {
+      const hubRate = status?.spawn_trace?.max_per_sec;
+      const localRate = getMaxSpawnPerSec();
+      if (typeof hubRate === "number" && hubRate !== localRate) {
+        console.warn(
+          `[headless] Hub version skew detected: hub spawn rate=${hubRate}/s, local=${localRate}/s. Restart hub to sync.`,
+        );
+      }
+    })
+    .catch(() => {});
+
   // Synapse: 세션 registration (fire-and-forget, hub 미응답 시 무시)
   const synapseIds = assignments.map((_, i) => `${sessionName}-worker-${i + 1}`);
   for (let i = 0; i < assignments.length; i++) {

package/hub/team/psmux.mjs

@@ -1273,6 +1273,7 @@ export async function waitForPattern(
 
 /**
  * 완료 토큰이 찍힐 때까지 대기하고 exit code를 파싱한다.
+ * NOTE: 주 채널은 headless.waitForCompletionWithStallDetect이며, 본 함수는 fallback 채널이다.
  * @param {string} sessionName
  * @param {string} paneNameOrTarget
  * @param {string} token