triflux 10.4.0 → 10.7.0

package/hub/team/remote-watcher.mjs

@@ -9,9 +9,8 @@
 
 import { execFileSync } from "node:child_process";
 import { EventEmitter } from "node:events";
-
+import { detectHostOs, shellQuoteForHost } from "../lib/ssh-command.mjs";
 import { detectInputWait, PROBE_LEVELS } from "./health-probe.mjs";
-import { shellQuoteForHost, detectHostOs } from "../lib/ssh-command.mjs";
 
 export const REMOTE_WATCHER_STATES = Object.freeze({
   WATCHING: "watching",
@@ -62,7 +61,10 @@ function freezeStatus(status) {
     Object.fromEntries(
       Object.entries(status.sessions || {})
         .sort(([left], [right]) => left.localeCompare(right))
-        .map(([sessionName, record]) => [sessionName, freezeSessionRecord(record)]),
+        .map(([sessionName, record]) => [
+          sessionName,
+          freezeSessionRecord(record),
+        ]),
     ),
   );
 
@@ -117,7 +119,9 @@ function hasMeaningfulActivity(captured) {
 }
 
 function detectCompletion(captured) {
-  const matches = Array.from(String(captured || "").matchAll(COMPLETION_TOKEN_RE));
+  const matches = Array.from(
+    String(captured || "").matchAll(COMPLETION_TOKEN_RE),
+  );
   const match = matches.at(-1);
   if (!match) {
     return {
@@ -128,7 +132,8 @@ function detectCompletion(captured) {
     };
   }
 
-  const parsedExitCode = match[2] == null ? null : Number.parseInt(match[2], 10);
+  const parsedExitCode =
+    match[2] == null ? null : Number.parseInt(match[2], 10);
   return {
     detected: true,
     exitCode: Number.isFinite(parsedExitCode) ? parsedExitCode : null,
@@ -143,7 +148,10 @@ function parseSessionNames(rawOutput, sessionPrefix) {
     .map((line) => line.trim())
     .filter(Boolean)
     .map((line) => line.split(":")[0]?.trim())
-    .filter((sessionName) => Boolean(sessionName) && sessionName.startsWith(sessionPrefix));
+    .filter(
+      (sessionName) =>
+        Boolean(sessionName) && sessionName.startsWith(sessionPrefix),
+    );
 }
 
 function buildExecOptions(config) {
@@ -187,7 +195,9 @@ function captureSpawnSession(sessionName, config) {
   );
   return {
     paneTarget,
-    captured: String(output || "").replace(/\r/g, "").trimEnd(),
+    captured: String(output || "")
+      .replace(/\r/g, "")
+      .trimEnd(),
   };
 }
 
@@ -221,7 +231,10 @@ function createSessionRecord(sessionName, config, now) {
 }
 
 function isTerminalState(state) {
-  return state === REMOTE_WATCHER_STATES.COMPLETED || state === REMOTE_WATCHER_STATES.FAILED;
+  return (
+    state === REMOTE_WATCHER_STATES.COMPLETED ||
+    state === REMOTE_WATCHER_STATES.FAILED
+  );
 }
 
 export function createRemoteWatcher(opts = {}) {
@@ -252,26 +265,30 @@ export function createRemoteWatcher(opts = {}) {
   }
 
   function emitSessionEvent(eventName, nextRecord, now) {
-    emitter.emit(eventName, Object.freeze({
-      exitCode: nextRecord.exitCode,
-      host: nextRecord.host,
-      inputWaitPattern: nextRecord.inputWaitPattern,
-      output: nextRecord.lastOutput,
-      paneTarget: nextRecord.paneTarget,
-      probeLevel: nextRecord.lastProbeLevel,
-      promptIdlePattern: nextRecord.promptIdlePattern,
-      reason: nextRecord.reason,
-      sessionName: nextRecord.sessionName,
-      state: nextRecord.state,
-      ts: now,
-    }));
+    emitter.emit(
+      eventName,
+      Object.freeze({
+        exitCode: nextRecord.exitCode,
+        host: nextRecord.host,
+        inputWaitPattern: nextRecord.inputWaitPattern,
+        output: nextRecord.lastOutput,
+        paneTarget: nextRecord.paneTarget,
+        probeLevel: nextRecord.lastProbeLevel,
+        promptIdlePattern: nextRecord.promptIdlePattern,
+        reason: nextRecord.reason,
+        sessionName: nextRecord.sessionName,
+        state: nextRecord.state,
+        ts: now,
+      }),
+    );
   }
 
   function classifySession(previousRecord, captured, now) {
     const completion = detectCompletion(captured);
     const inputWait = detectInputWait(captured);
     const promptIdle = detectPromptIdle(captured);
-    const hasActivity = previousRecord.hasActivity || hasMeaningfulActivity(captured);
+    const hasActivity =
+      previousRecord.hasActivity || hasMeaningfulActivity(captured);
 
     let nextState = REMOTE_WATCHER_STATES.WATCHING;
     let reason = "watching";
@@ -292,9 +309,9 @@ export function createRemoteWatcher(opts = {}) {
         eventName = "sessionCompleted";
       }
     } else if (
-      promptIdle.detected
-      && hasActivity
-      && (!inputWait.detected || inputWait.pattern === BARE_INPUT_WAIT_PATTERN)
+      promptIdle.detected &&
+      hasActivity &&
+      (!inputWait.detected || inputWait.pattern === BARE_INPUT_WAIT_PATTERN)
     ) {
       nextState = REMOTE_WATCHER_STATES.COMPLETED;
       reason = "prompt_idle";
@@ -325,10 +342,10 @@ export function createRemoteWatcher(opts = {}) {
     };
 
     if (
-      eventName
-      && previousRecord.state === nextRecord.state
-      && previousRecord.reason === nextRecord.reason
-      && previousRecord.exitCode === nextRecord.exitCode
+      eventName &&
+      previousRecord.state === nextRecord.state &&
+      previousRecord.reason === nextRecord.reason &&
+      previousRecord.exitCode === nextRecord.exitCode
     ) {
       return { eventName: null, nextRecord };
     }
@@ -375,7 +392,10 @@ export function createRemoteWatcher(opts = {}) {
           : createSessionRecord(sessionName, config, now);
 
         try {
-          const { paneTarget, captured } = captureSpawnSession(sessionName, config);
+          const { paneTarget, captured } = captureSpawnSession(
+            sessionName,
+            config,
+          );
           const { eventName, nextRecord } = classifySession(
             { ...previousRecord, paneTarget },
             captured,
@@ -396,7 +416,10 @@ export function createRemoteWatcher(opts = {}) {
             state: REMOTE_WATCHER_STATES.FAILED,
           };
           nextSessions[sessionName] = failedRecord;
-          queuedEvents.push({ eventName: "sessionFailed", record: failedRecord });
+          queuedEvents.push({
+            eventName: "sessionFailed",
+            record: failedRecord,
+          });
           setStatus({
             ...status,
             lastError: toErrorRecord(error),
@@ -407,9 +430,14 @@ export function createRemoteWatcher(opts = {}) {
         }
       }
 
-      for (const [sessionName, previousRecord] of Object.entries(status.sessions)) {
+      for (const [sessionName, previousRecord] of Object.entries(
+        status.sessions,
+      )) {
         if (activeSet.has(sessionName)) continue;
-        const { eventName, nextRecord } = markMissingSession(previousRecord, now);
+        const { eventName, nextRecord } = markMissingSession(
+          previousRecord,
+          now,
+        );
         nextSessions[sessionName] = nextRecord;
         if (eventName) {
           queuedEvents.push({ eventName, record: nextRecord });

package/hub/team/routing.mjs

@@ -15,31 +15,55 @@
 export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   const N = subtasks.length;
   if (N === 0) {
-    const dagContext = { dag_width: 0, levels: {}, edges: [], max_complexity: 'S', taskResults: {} };
-    return { strategy: 'quick_single', reason: 'empty_subtasks', dag_width: 0, max_complexity: 'S', dagContext };
+    const dagContext = {
+      dag_width: 0,
+      levels: {},
+      edges: [],
+      max_complexity: "S",
+      taskResults: {},
+    };
+    return {
+      strategy: "quick_single",
+      reason: "empty_subtasks",
+      dag_width: 0,
+      max_complexity: "S",
+      dagContext,
+    };
   }
 
-  const { width: dag_width, levels, edges } = computeDagInfo(subtasks, graph_type);
+  const {
+    width: dag_width,
+    levels,
+    edges,
+  } = computeDagInfo(subtasks, graph_type);
   const max_complexity = getMaxComplexity(subtasks);
-  const dagContext = { dag_width, levels, edges, max_complexity, taskResults: {} };
-  const isHighComplexity = ['L', 'XL'].includes(max_complexity);
+  const dagContext = {
+    dag_width,
+    levels,
+    edges,
+    max_complexity,
+    taskResults: {},
+  };
+  const isHighComplexity = ["L", "XL"].includes(max_complexity);
   const allSameAgent = new Set(subtasks.map((s) => s.agent)).size === 1;
-  const allSmall = subtasks.every((s) => normalizeComplexity(s.complexity) === 'S');
+  const allSmall = subtasks.every(
+    (s) => normalizeComplexity(s.complexity) === "S",
+  );
 
   // N==1: 단일 태스크
   if (N === 1) {
     if (thorough || isHighComplexity) {
       return {
-        strategy: 'thorough_single',
-        reason: 'single_high_complexity',
+        strategy: "thorough_single",
+        reason: "single_high_complexity",
         dag_width,
         max_complexity,
         dagContext,
       };
     }
     return {
-      strategy: 'quick_single',
-      reason: 'single_low_complexity',
+      strategy: "quick_single",
+      reason: "single_low_complexity",
       dag_width,
       max_complexity,
       dagContext,
@@ -50,16 +74,16 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   if (dag_width === 1) {
     if (thorough || isHighComplexity) {
       return {
-        strategy: 'thorough_single',
-        reason: 'sequential_chain',
+        strategy: "thorough_single",
+        reason: "sequential_chain",
         dag_width,
         max_complexity,
         dagContext,
       };
     }
     return {
-      strategy: 'quick_single',
-      reason: 'sequential_chain',
+      strategy: "quick_single",
+      reason: "sequential_chain",
       dag_width,
       max_complexity,
       dagContext,
@@ -69,8 +93,8 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   // 동일 에이전트 + 모두 S: 프롬프트 병합 -> batch single
   if (allSameAgent && allSmall) {
     return {
-      strategy: 'batch_single',
-      reason: 'same_agent_small_batch',
+      strategy: "batch_single",
+      reason: "same_agent_small_batch",
       dag_width,
       max_complexity,
       dagContext,
@@ -80,16 +104,16 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
   // dag_width >= 2: 팀
   if (thorough || isHighComplexity) {
     return {
-      strategy: 'thorough_team',
-      reason: 'parallel_high_complexity',
+      strategy: "thorough_team",
+      reason: "parallel_high_complexity",
       dag_width,
       max_complexity,
       dagContext,
     };
   }
   return {
-    strategy: 'quick_team',
-    reason: 'parallel_low_complexity',
+    strategy: "quick_team",
+    reason: "parallel_low_complexity",
     dag_width,
     max_complexity,
     dagContext,
@@ -103,7 +127,7 @@ export function resolveRoutingStrategy({ subtasks, graph_type, thorough }) {
  * @returns {{ width: number, levels: Record<number, string[]>, edges: Array<{from:string, to:string}> }}
  */
 function computeDagInfo(subtasks, graph_type) {
-  if (graph_type === 'SEQUENTIAL') {
+  if (graph_type === "SEQUENTIAL") {
     const levels = {};
     const edges = [];
     subtasks.forEach((t, i) => {
@@ -112,7 +136,7 @@ function computeDagInfo(subtasks, graph_type) {
     });
     return { width: 1, levels, edges };
   }
-  if (graph_type === 'INDEPENDENT') {
+  if (graph_type === "INDEPENDENT") {
     const levels = { 0: subtasks.map((t) => t.id) };
     return { width: subtasks.length, levels, edges: [] };
   }
@@ -173,7 +197,9 @@ function computeDagInfo(subtasks, graph_type) {
 export function getUpstreamResults(taskId, pipelineState) {
   const ctx = pipelineState?.dagContext;
   if (!ctx) return {};
-  const upstreamIds = ctx.edges.filter((e) => e.to === taskId).map((e) => e.from);
+  const upstreamIds = ctx.edges
+    .filter((e) => e.to === taskId)
+    .map((e) => e.from);
   const results = {};
   for (const id of upstreamIds) {
     if (id in (ctx.taskResults || {})) {
@@ -205,7 +231,7 @@ export function updateTaskResult(taskId, result, pipelineState) {
  */
 function getMaxComplexity(subtasks) {
   const order = { S: 0, M: 1, L: 2, XL: 3 };
-  let max = 'S';
+  let max = "S";
   for (const s of subtasks) {
     const complexity = normalizeComplexity(s.complexity);
     if (order[complexity] > order[max]) max = complexity;
@@ -219,5 +245,5 @@ function getMaxComplexity(subtasks) {
  * @returns {"S" | "M" | "L" | "XL"}
  */
 function normalizeComplexity(complexity) {
-  return ['S', 'M', 'L', 'XL'].includes(complexity) ? complexity : 'M';
+  return ["S", "M", "L", "XL"].includes(complexity) ? complexity : "M";
 }

package/hub/team/runtime-strategy.mjs

@@ -60,7 +60,9 @@ export function createPsmuxRuntime(adapter = defaultPsmuxAdapter) {
  * @returns {TeamRuntime & { name: string }}
  */
 export function createRuntime(mode) {
-  const normalizedMode = String(mode || "").trim().toLowerCase();
+  const normalizedMode = String(mode || "")
+    .trim()
+    .toLowerCase();
 
   if (normalizedMode === "psmux") {
     return createPsmuxRuntime();