triflux 10.10.0 → 10.11.0

package/bin/triflux.mjs

@@ -882,7 +882,11 @@ function getClaudeRoutingSyncSummary(results) {
     (summary, result) => ({
       changed:
         summary.changed +
-        (result.action === "created" || result.action === "updated" ? 1 : 0),
+        (result.action === "created" ||
+        result.action === "updated" ||
+        result.action === "removed"
+          ? 1
+          : 0),
       skipped: summary.skipped + (result.skipped ? 1 : 0),
     }),
     { changed: 0, skipped: 0 },

package/hub/bridge.mjs

@@ -21,6 +21,12 @@ import { fileURLToPath } from "node:url";
 import { parseArgs as nodeParseArgs } from "node:util";
 
 import { getPipelineStateDbPath } from "./pipeline/state.mjs";
+import {
+  createRetryStateMachine,
+  DEFAULT_ESCALATION_CHAIN,
+  loadSnapshot,
+  saveSnapshot,
+} from "./team/retry-state-machine.mjs";
 
 const HUB_PID_FILE = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
 const HUB_TOKEN_FILE = join(homedir(), ".claude", ".tfx-hub-token");
@@ -409,6 +415,10 @@ export function parseArgs(argv) {
       done: { type: "boolean" },
       "mcp-profile": { type: "string" },
       "session-key": { type: "string" },
+      snapshot: { type: "string" },
+      "snapshot-file": { type: "string" },
+      event: { type: "string" },
+      "max-iterations": { type: "string" },
     },
     allowPositionals: true,
     strict: false,
@@ -1079,6 +1089,124 @@ async function cmdHitlPending() {
   return emitJson(outcome?.result || unavailableResult());
 }
 
+// ---------------------------------------------------------------------------
+// retry-run / retry-status — Phase 3 Step C2 bridge 서브커맨드.
+// retry-state-machine.mjs 를 multi-process safe 하게 외부 호출용 wrap.
+// 사용자 워크플로우:
+//   1) 첫 호출: retry-run --snapshot X --mode ralph --event start
+//      → 새 SM 생성, PLANNING → EXECUTING transition, snapshot 저장
+//   2) verify 성공 시: retry-run --snapshot X --event verify-success
+//      → DONE, 종료 판단 반환
+//   3) verify 실패 시: retry-run --snapshot X --event verify-fail --reason R
+//      → DIAGNOSING 또는 STUCK/BUDGET_EXCEEDED, 종료 판단 반환
+//   4) 다음 iter 시작: retry-run --snapshot X --event start
+// 출력: {ok, current, iterations, done, shouldStop, reason?, cli?} JSON.
+// ---------------------------------------------------------------------------
+
+function buildRetrySmFromArgs(args, snapshot) {
+  const mode = args.mode || snapshot?.mode || "bounded";
+  const maxIterations =
+    args["max-iterations"] !== undefined
+      ? Number(args["max-iterations"])
+      : snapshot?.maxIterations;
+  const sessionId = args["session-id"] || snapshot?.sessionId || null;
+  const cliChain = snapshot?.cliChain;
+
+  const sm = createRetryStateMachine({
+    mode,
+    maxIterations,
+    sessionId,
+    cliChain,
+  });
+  if (snapshot) sm.applySnapshot(snapshot);
+  return sm;
+}
+
+async function cmdRetryRun(args) {
+  const snapshotFile = args.snapshot || args["snapshot-file"];
+  const event = args.event;
+  const reason = args.reason || "";
+
+  if (!snapshotFile) {
+    console.error("--snapshot <path> required");
+    return false;
+  }
+  if (!event) {
+    console.error("--event <start|verify-success|verify-fail> required");
+    return false;
+  }
+
+  const existing = loadSnapshot(snapshotFile);
+  const sm = buildRetrySmFromArgs(args, existing);
+
+  let result;
+  switch (event) {
+    case "start":
+      result = sm.startIteration();
+      break;
+    case "verify-success":
+      result = sm.reportVerifySuccess();
+      break;
+    case "verify-fail":
+      result = sm.reportVerifyFail(reason || "unspecified");
+      break;
+    default:
+      console.error(`unknown --event: ${event}`);
+      return false;
+  }
+
+  const snap = sm.serialize();
+  saveSnapshot(snapshotFile, snap);
+
+  const terminal = ["DONE", "STUCK", "BUDGET_EXCEEDED"].includes(snap.current);
+  const cli = snap.cliChain?.[snap.cliIndex] || null;
+  const out = {
+    ok: true,
+    current: snap.current,
+    iterations: snap.iterations,
+    cliIndex: snap.cliIndex,
+    cli,
+    done: snap.current === "DONE",
+    shouldStop: terminal,
+    stuckCounter: snap.stuckCounter,
+    lastFailureReason: snap.lastFailureReason,
+    transition: result,
+  };
+  console.log(JSON.stringify(out));
+  return true;
+}
+
+async function cmdRetryStatus(args) {
+  const snapshotFile = args.snapshot || args["snapshot-file"];
+  if (!snapshotFile) {
+    console.error("--snapshot <path> required");
+    return false;
+  }
+  const snap = loadSnapshot(snapshotFile);
+  if (!snap) {
+    console.log(JSON.stringify({ ok: true, exists: false }));
+    return true;
+  }
+  const terminal = ["DONE", "STUCK", "BUDGET_EXCEEDED"].includes(snap.current);
+  const cli = snap.cliChain?.[snap.cliIndex] || null;
+  console.log(
+    JSON.stringify({
+      ok: true,
+      exists: true,
+      current: snap.current,
+      iterations: snap.iterations,
+      maxIterations: snap.maxIterations,
+      cliIndex: snap.cliIndex,
+      cli,
+      mode: snap.mode,
+      shouldStop: terminal,
+      stuckCounter: snap.stuckCounter,
+      lastFailureReason: snap.lastFailureReason,
+    }),
+  );
+  return true;
+}
+
 export async function main(argv = process.argv.slice(2)) {
   const cmd = argv[0];
   const args = parseArgs(argv.slice(1));
@@ -1138,9 +1266,13 @@ export async function main(argv = process.argv.slice(2)) {
       return await cmdHitlSubmit(args);
     case "hitl-pending":
       return await cmdHitlPending(args);
+    case "retry-run":
+      return await cmdRetryRun(args);
+    case "retry-status":
+      return await cmdRetryStatus(args);
     default:
       console.error(
-        "사용법: bridge.mjs <register|result|control|handoff|publish|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending> [--옵션]",
+        "사용법: bridge.mjs <register|result|control|handoff|publish|send-input|context|deregister|assign-async|assign-result|assign-status|assign-retry|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|pipeline-init|pipeline-list|ping|delegator-delegate|delegator-reply|delegator-status|hitl-request|hitl-submit|hitl-pending|retry-run|retry-status> [--옵션]",
       );
       process.exit(1);
   }

package/hub/lib/tfx-route-args.mjs

@@ -0,0 +1,222 @@
+// hub/lib/tfx-route-args.mjs
+// Phase 3 Step B — tfx-auto / tfx-route 플래그 파서.
+// 설계 문서: .triflux/plans/phase3-lead-codex-ralph-escalate.md
+//
+// 입력: ARGUMENTS 문자열 또는 토큰 배열.
+// 출력: {cli, mode, parallel, retry, isolation, remote, lead, noClaudeNative,
+//        maxIterations, task, warnings}.
+//
+// 기존 플래그 (Phase 2 v10.9.33+):
+//   --cli {auto|codex|gemini|claude}
+//   --mode {quick|deep|consensus}
+//   --parallel {1|N|swarm}
+//   --retry {0|1|ralph|auto-escalate}    (Phase 3 에서 ralph/auto-escalate 신규)
+//   --isolation {none|worktree}
+//   --remote {none|<host>}
+//
+// Phase 3 신규:
+//   --lead {claude|codex}             (tfx-auto-codex 의미 흡수)
+//   --no-claude-native                (Claude native sub-agent 경로 disable)
+//   --max-iterations <N>              (ralph / auto-escalate 상한, 0=unlimited)
+
+export const DEFAULT_OPTIONS = Object.freeze({
+  cli: "auto",
+  mode: "quick",
+  parallel: "1",
+  retry: "1",
+  isolation: "none",
+  remote: "none",
+  lead: "claude",
+  noClaudeNative: false,
+  maxIterations: 0,
+});
+
+const VALID_VALUES = Object.freeze({
+  cli: ["auto", "codex", "gemini", "claude"],
+  mode: ["quick", "deep", "consensus"],
+  retry: ["0", "1", "ralph", "auto-escalate"],
+  isolation: ["none", "worktree"],
+  lead: ["claude", "codex"],
+});
+
+const VALUE_FLAGS = new Set([
+  "--cli",
+  "--mode",
+  "--parallel",
+  "--retry",
+  "--isolation",
+  "--remote",
+  "--lead",
+  "--max-iterations",
+]);
+
+const BOOL_FLAGS = new Set(["--no-claude-native"]);
+
+export function parseArgs(input) {
+  const tokens = Array.isArray(input)
+    ? input.slice()
+    : tokenize(String(input || ""));
+  const opts = { ...DEFAULT_OPTIONS };
+  const warnings = [];
+  const taskTokens = [];
+
+  let i = 0;
+  while (i < tokens.length) {
+    const raw = tokens[i];
+
+    if (BOOL_FLAGS.has(raw)) {
+      applyBool(opts, raw);
+      i += 1;
+      continue;
+    }
+
+    // --flag=value 지원
+    const eqIdx = raw.indexOf("=");
+    let flag = raw;
+    let value = null;
+    if (eqIdx > 0 && raw.startsWith("--")) {
+      flag = raw.slice(0, eqIdx);
+      value = raw.slice(eqIdx + 1);
+    }
+
+    if (VALUE_FLAGS.has(flag)) {
+      if (value === null) {
+        const next = tokens[i + 1];
+        if (next === undefined || next.startsWith("--")) {
+          warnings.push(`${flag} needs a value`);
+          i += 1;
+          continue;
+        }
+        value = next;
+        i += 2;
+      } else {
+        i += 1;
+      }
+      applyValue(opts, flag, value, warnings);
+      continue;
+    }
+
+    if (raw.startsWith("--")) {
+      warnings.push(`unknown flag: ${raw}`);
+      i += 1;
+      continue;
+    }
+
+    taskTokens.push(raw);
+    i += 1;
+  }
+
+  validate(opts, warnings);
+
+  return {
+    ...opts,
+    task: taskTokens.join(" ").trim(),
+    warnings,
+  };
+}
+
+function tokenize(str) {
+  const tokens = [];
+  let cur = "";
+  let quote = null;
+  for (const ch of str) {
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        cur += ch;
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (cur) {
+        tokens.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur) tokens.push(cur);
+  return tokens;
+}
+
+function applyBool(opts, flag) {
+  switch (flag) {
+    case "--no-claude-native":
+      opts.noClaudeNative = true;
+      break;
+  }
+}
+
+function applyValue(opts, flag, value, warnings) {
+  switch (flag) {
+    case "--cli":
+      opts.cli = value;
+      break;
+    case "--mode":
+      opts.mode = value;
+      break;
+    case "--parallel":
+      opts.parallel = value;
+      break;
+    case "--retry":
+      opts.retry = value;
+      break;
+    case "--isolation":
+      opts.isolation = value;
+      break;
+    case "--remote":
+      opts.remote = value;
+      break;
+    case "--lead":
+      opts.lead = value;
+      break;
+    case "--max-iterations": {
+      const n = Number.parseInt(value, 10);
+      if (Number.isNaN(n) || n < 0) {
+        warnings.push(
+          `invalid --max-iterations=${value}, expected non-negative integer (0=unlimited)`,
+        );
+      } else {
+        opts.maxIterations = n;
+      }
+      break;
+    }
+  }
+}
+
+function validate(opts, warnings) {
+  for (const key of Object.keys(VALID_VALUES)) {
+    if (!VALID_VALUES[key].includes(opts[key])) {
+      warnings.push(
+        `invalid --${key}=${opts[key]}, expected one of ${VALID_VALUES[key].join("|")}`,
+      );
+    }
+  }
+  if (
+    opts.parallel !== "1" &&
+    opts.parallel !== "swarm" &&
+    !/^\d+$/.test(opts.parallel)
+  ) {
+    warnings.push(`invalid --parallel=${opts.parallel}, expected 1|N|swarm`);
+  }
+  const parallelOne = opts.parallel === "1" || opts.parallel === 1;
+  if (parallelOne && opts.isolation === "worktree") {
+    warnings.push(
+      "--isolation worktree requires --parallel >=2 or swarm; forcing isolation=none",
+    );
+    opts.isolation = "none";
+  }
+  if (opts.remote !== "none" && opts.parallel !== "swarm") {
+    warnings.push(
+      `--remote ${opts.remote} ignored (requires --parallel swarm)`,
+    );
+  }
+}
+
+export { VALID_VALUES };

package/hub/server.mjs

@@ -1057,7 +1057,7 @@ export async function startHub({
       if (path === "/synapse/heartbeat" && req.method === "POST") {
         try {
           const body = await parseBody(req);
-          const { sessionId, ...partial } = body || {};
+          const { sessionId, partial } = body || {};
           const ok = synapseRegistry.heartbeat(sessionId, partial);
           if (!ok) {
             throw new Error("heartbeat failed");

package/hub/team/git-preflight.mjs

@@ -80,12 +80,12 @@ export function createGitPreflight(opts = {}) {
   }
 
   function otherActiveSessions(active, sessionId) {
-    return active.filter((s) => s && s.sessionId && s.sessionId !== sessionId);
+    return active.filter((s) => s?.sessionId && s.sessionId !== sessionId);
   }
 
   function otherLeases(snapshot, workerId) {
     return snapshot.filter(
-      (entry) => entry && entry.workerId && entry.workerId !== workerId,
+      (entry) => entry?.workerId && entry.workerId !== workerId,
     );
   }
 

package/hub/team/retry-state-machine.mjs

@@ -0,0 +1,260 @@
+// hub/team/retry-state-machine.mjs
+// Phase 3 Step A — true ralph / auto-escalate retry state machine.
+// 설계 문서: .triflux/plans/phase3-lead-codex-ralph-escalate.md
+//
+// Modes:
+//   bounded       — --retry 1 (기본): maxIterations 도달 시 BUDGET_EXCEEDED.
+//   ralph         — --retry ralph: maxIterations=0 이면 unlimited. stuck detector 만 종료.
+//   auto-escalate — --retry auto-escalate: BUDGET_EXCEEDED 시 다음 CLI 로 전이.
+//
+// 상태 전이:
+//   PLANNING → EXECUTING → VERIFYING.success → DONE
+//                       → VERIFYING.fail   → DIAGNOSING → EXECUTING …
+//                       → stuckCounter≥3   → STUCK
+//                       → iter≥max         → BUDGET_EXCEEDED (escalate 모드는 다음 CLI)
+
+import { EventEmitter } from "node:events";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname } from "node:path";
+
+export const STATES = Object.freeze({
+  PLANNING: "PLANNING",
+  EXECUTING: "EXECUTING",
+  DIAGNOSING: "DIAGNOSING",
+  STUCK: "STUCK",
+  BUDGET_EXCEEDED: "BUDGET_EXCEEDED",
+  DONE: "DONE",
+});
+
+export const MODES = Object.freeze({
+  BOUNDED: "bounded",
+  RALPH: "ralph",
+  ESCALATE: "auto-escalate",
+});
+
+const DEFAULT_ESCALATION_CHAIN = Object.freeze([
+  Object.freeze({ cli: "codex", model: "gpt-5-mini" }),
+  Object.freeze({ cli: "codex", model: "gpt-5" }),
+  Object.freeze({ cli: "claude", model: "sonnet-4-6" }),
+  Object.freeze({ cli: "claude", model: "opus-4-7" }),
+]);
+
+const STUCK_THRESHOLD = 3;
+
+export function createRetryStateMachine(options = {}) {
+  const mode = options.mode || MODES.BOUNDED;
+  const cliChain = Array.isArray(options.cliChain)
+    ? options.cliChain.slice()
+    : DEFAULT_ESCALATION_CHAIN.slice();
+  const maxIterationsInput =
+    typeof options.maxIterations === "number" ? options.maxIterations : null;
+  const maxIterations =
+    maxIterationsInput !== null
+      ? maxIterationsInput
+      : mode === MODES.BOUNDED
+        ? 3
+        : 0;
+  const stateFile = options.stateFile || null;
+  const sessionId = options.sessionId || null;
+
+  const emitter = new EventEmitter();
+  const state = {
+    current: STATES.PLANNING,
+    iterations: 0,
+    maxIterations,
+    stuckCounter: 0,
+    lastFailureReason: null,
+    cliIndex: 0,
+    cliChain,
+    mode,
+    sessionId,
+    stateFile,
+    history: [],
+  };
+
+  function transition(next, meta = {}) {
+    const prev = state.current;
+    state.current = next;
+    const entry = {
+      t: Date.now(),
+      from: prev,
+      to: next,
+      iteration: state.iterations,
+      cliIndex: state.cliIndex,
+      ...meta,
+    };
+    state.history.push(entry);
+    if (stateFile) persistTransition(stateFile, entry);
+    emitter.emit("transition", entry);
+    return entry;
+  }
+
+  function startIteration() {
+    state.iterations += 1;
+    return transition(STATES.EXECUTING, { iteration: state.iterations });
+  }
+
+  function reportVerifySuccess() {
+    return transition(STATES.DONE);
+  }
+
+  function reportVerifyFail(failureReason) {
+    const reason = String(failureReason || "unknown");
+    if (reason === state.lastFailureReason) {
+      state.stuckCounter += 1;
+    } else {
+      state.stuckCounter = 1;
+      state.lastFailureReason = reason;
+    }
+
+    if (state.stuckCounter >= STUCK_THRESHOLD) {
+      return transition(STATES.STUCK, {
+        reason,
+        stuckCounter: state.stuckCounter,
+      });
+    }
+
+    if (state.maxIterations > 0 && state.iterations >= state.maxIterations) {
+      if (state.mode === MODES.ESCALATE) {
+        return escalate();
+      }
+      return transition(STATES.BUDGET_EXCEEDED, {
+        reason,
+        iterations: state.iterations,
+      });
+    }
+
+    return transition(STATES.DIAGNOSING, { reason });
+  }
+
+  function escalate() {
+    if (state.cliIndex + 1 >= state.cliChain.length) {
+      return transition(STATES.BUDGET_EXCEEDED, {
+        reason: "escalation-chain-exhausted",
+        chain: state.cliChain,
+      });
+    }
+    state.cliIndex += 1;
+    state.iterations = 0;
+    state.stuckCounter = 0;
+    state.lastFailureReason = null;
+    return transition(STATES.EXECUTING, {
+      cli: state.cliChain[state.cliIndex],
+      escalated: true,
+    });
+  }
+
+  function getCurrent() {
+    return {
+      current: state.current,
+      iterations: state.iterations,
+      maxIterations: state.maxIterations,
+      stuckCounter: state.stuckCounter,
+      lastFailureReason: state.lastFailureReason,
+      cliIndex: state.cliIndex,
+      cliChain: state.cliChain.slice(),
+      mode: state.mode,
+      sessionId: state.sessionId,
+      history: state.history.slice(),
+    };
+  }
+
+  function on(event, listener) {
+    emitter.on(event, listener);
+    return () => emitter.off(event, listener);
+  }
+
+  function serialize() {
+    return {
+      version: 1,
+      current: state.current,
+      iterations: state.iterations,
+      maxIterations: state.maxIterations,
+      stuckCounter: state.stuckCounter,
+      lastFailureReason: state.lastFailureReason,
+      cliIndex: state.cliIndex,
+      cliChain: state.cliChain.slice(),
+      mode: state.mode,
+      sessionId: state.sessionId,
+      history: state.history.slice(),
+    };
+  }
+
+  function applySnapshot(snapshot) {
+    if (!snapshot || typeof snapshot !== "object") return;
+    state.current = snapshot.current || STATES.PLANNING;
+    state.iterations = Number(snapshot.iterations) || 0;
+    state.maxIterations =
+      snapshot.maxIterations !== undefined
+        ? Number(snapshot.maxIterations)
+        : state.maxIterations;
+    state.stuckCounter = Number(snapshot.stuckCounter) || 0;
+    state.lastFailureReason = snapshot.lastFailureReason || null;
+    state.cliIndex = Number(snapshot.cliIndex) || 0;
+    if (Array.isArray(snapshot.cliChain) && snapshot.cliChain.length > 0) {
+      state.cliChain = snapshot.cliChain.slice();
+    }
+    if (snapshot.mode) state.mode = snapshot.mode;
+    if (snapshot.sessionId !== undefined) state.sessionId = snapshot.sessionId;
+    if (Array.isArray(snapshot.history))
+      state.history = snapshot.history.slice();
+  }
+
+  return {
+    STATES,
+    MODES,
+    getCurrent,
+    startIteration,
+    reportVerifySuccess,
+    reportVerifyFail,
+    escalate,
+    on,
+    serialize,
+    applySnapshot,
+  };
+}
+
+function persistTransition(stateFile, entry) {
+  const dir = dirname(stateFile);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  appendFileSync(stateFile, `${JSON.stringify(entry)}\n`, "utf8");
+}
+
+export function resumeFromStateFile(stateFile) {
+  if (!existsSync(stateFile)) return null;
+  const raw = readFileSync(stateFile, "utf8").trim();
+  if (!raw) return null;
+  const lines = raw.split("\n").filter(Boolean);
+  if (lines.length === 0) return null;
+  return JSON.parse(lines[lines.length - 1]);
+}
+
+// Full-snapshot 기반 stateFile I/O — bridge retry-run 에서 multi-process state 복원용.
+// transition event log (resumeFromStateFile) 와 별도 파일로 관리하는 것을 권장.
+export function loadSnapshot(snapshotFile) {
+  if (!existsSync(snapshotFile)) return null;
+  const raw = readFileSync(snapshotFile, "utf8").trim();
+  if (!raw) return null;
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object") return null;
+  if (parsed.version !== 1) {
+    throw new Error(
+      `unsupported snapshot version: ${parsed.version} (expected 1)`,
+    );
+  }
+  return parsed;
+}
+
+export function saveSnapshot(snapshotFile, snapshot) {
+  const dir = dirname(snapshotFile);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(snapshotFile, JSON.stringify(snapshot), "utf8");
+}
+
+export { DEFAULT_ESCALATION_CHAIN, STUCK_THRESHOLD };

package/hub/team/runtime-strategy.mjs

@@ -3,11 +3,7 @@ import {
   killPsmuxSession,
   psmuxSessionExists,
 } from "./psmux.mjs";
-import {
-  killSession as killTmuxSession,
-  listSessions,
-  tmuxExec,
-} from "./session.mjs";
+import { tmuxExec } from "./session.mjs";
 
 /**
  * @typedef {object} RuntimeStatus