@triflux/core 10.43.0 → 10.45.0

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

@@ -8,11 +8,12 @@
 //
 // 기존 플래그 (Phase 2 v10.9.33+):
 //   --cli {auto|codex|antigravity|claude}
-//   --mode {quick|deep|consensus}
+//   --mode {quick|deep|consensus|live}
 //   --parallel {1|N|swarm}
 //   --retry {0|1|ralph|auto-escalate}    (Phase 3 에서 ralph/auto-escalate 신규)
 //   --isolation {none|worktree}
 //   --remote {none|<host>}
+//   --rounds <N>                          (--mode live 전용, 기본 4)
 //
 // Phase 3 신규:
 //   --lead {claude|codex}             (tfx-auto-codex 의미 흡수)
@@ -31,11 +32,12 @@ export const DEFAULT_OPTIONS = Object.freeze({
   lead: "claude",
   noClaudeNative: false,
   maxIterations: 0,
+  rounds: 4,
 });
 
 const VALID_VALUES = Object.freeze({
   cli: ["auto", "codex", "antigravity", "claude"],
-  mode: ["quick", "deep", "consensus"],
+  mode: ["quick", "deep", "consensus", "live"],
   retry: ["0", "1", "ralph", "auto-escalate"],
   isolation: ["none", "worktree"],
   lead: ["claude", "codex"],
@@ -50,6 +52,7 @@ const VALUE_FLAGS = new Set([
   "--remote",
   "--lead",
   "--max-iterations",
+  "--rounds",
 ]);
 
 const BOOL_FLAGS = new Set(["--no-claude-native"]);
@@ -61,12 +64,14 @@ export function parseArgs(input) {
   const opts = { ...DEFAULT_OPTIONS };
   const warnings = [];
   const taskTokens = [];
+  const providedFlags = new Set();
 
   let i = 0;
   while (i < tokens.length) {
     const raw = tokens[i];
 
     if (BOOL_FLAGS.has(raw)) {
+      providedFlags.add(raw);
       applyBool(opts, raw);
       i += 1;
       continue;
@@ -82,6 +87,7 @@ export function parseArgs(input) {
     }
 
     if (VALUE_FLAGS.has(flag)) {
+      providedFlags.add(flag);
       if (value === null) {
         const next = tokens[i + 1];
         if (next === undefined || next.startsWith("--")) {
@@ -108,7 +114,7 @@ export function parseArgs(input) {
     i += 1;
   }
 
-  validate(opts, warnings);
+  validate(opts, warnings, providedFlags);
 
   return {
     ...opts,
@@ -196,10 +202,19 @@ function applyValue(opts, flag, value, warnings) {
       }
       break;
     }
+    case "--rounds": {
+      const n = Number(value);
+      if (!Number.isInteger(n) || n <= 0) {
+        warnings.push(`invalid --rounds=${value}, expected positive integer`);
+      } else {
+        opts.rounds = n;
+      }
+      break;
+    }
   }
 }
 
-function validate(opts, warnings) {
+function validate(opts, warnings, providedFlags = new Set()) {
   for (const key of Object.keys(VALID_VALUES)) {
     if (!VALID_VALUES[key].includes(opts[key])) {
       warnings.push(
@@ -214,6 +229,28 @@ function validate(opts, warnings) {
   ) {
     warnings.push(`invalid --parallel=${opts.parallel}, expected 1|N|swarm`);
   }
+
+  if (opts.mode === "live") {
+    const ignored = [
+      ["--parallel", "parallel", DEFAULT_OPTIONS.parallel],
+      ["--isolation", "isolation", DEFAULT_OPTIONS.isolation],
+      ["--remote", "remote", DEFAULT_OPTIONS.remote],
+    ];
+    for (const [flag, key, fallback] of ignored) {
+      if (providedFlags.has(flag)) {
+        warnings.push(`${flag} ignored with --mode live`);
+        opts[key] = fallback;
+      }
+    }
+    if (providedFlags.has("--retry") && opts.retry === "ralph") {
+      warnings.push("--retry ralph ignored with --mode live");
+      opts.retry = DEFAULT_OPTIONS.retry;
+    }
+  } else if (providedFlags.has("--rounds")) {
+    warnings.push("--rounds ignored unless --mode live");
+    opts.rounds = DEFAULT_OPTIONS.rounds;
+  }
+
   const parallelOne = opts.parallel === "1" || opts.parallel === 1;
   if (parallelOne && opts.isolation === "worktree") {
     warnings.push(

package/hub/reflexion.mjs

@@ -7,8 +7,6 @@ const DEFAULT_CONFIDENCE = 0.5;
 const ACTIVE_RULE_CONFIDENCE = 0.5;
 const ADAPTIVE_PROMOTION_STEP = 0.1;
 const ADAPTIVE_DECAY_STEP = 0.1;
-/** @deprecated 세션 기반 decay에서 시간 기반으로 변경됨. 미사용. */
-const _ADAPTIVE_DECAY_WINDOW = 5;
 const ADAPTIVE_DELETE_THRESHOLD = 0.3;
 
 function clampConfidence(value) {
@@ -102,61 +100,6 @@ function buildAdaptiveSolution(errorContext = {}, errorText = "") {
   return `${toolName} 재시도 전 실패 원인을 검증하세요: ${summary}`;
 }
 
-function normalizeSessionIds(sessionIds) {
-  if (!Array.isArray(sessionIds)) return [];
-  return [
-    ...new Set(
-      sessionIds.filter((value) => typeof value === "string" && value.trim()),
-    ),
-  ];
-}
-
-/** @deprecated reflexion_entries 기반. adaptive_rules에서는 미사용. 세션 인식 복원 시 재활용 예정. */
-function getAdaptiveState(rule = {}) {
-  const state = rule.adaptive_state || {};
-  const session_ids = normalizeSessionIds(state.session_ids);
-  return {
-    ...state,
-    project_slug: pickString(state.project_slug, rule.context?.project_slug),
-    session_ids,
-    session_occurrences: Math.max(
-      state.session_occurrences || 0,
-      session_ids.length,
-    ),
-    last_seen_session: pickSessionCount(state.last_seen_session),
-    last_decay_session: pickSessionCount(state.last_decay_session),
-  };
-}
-
-/** @deprecated reflexion_entries 기반. adaptive_rules에서는 미사용. 세션 인식 복원 시 재활용 예정. */
-function _mergeAdaptiveState(rule, errorContext = {}) {
-  const current = getAdaptiveState(rule);
-  const sessionId = pickSessionId(errorContext);
-  const sessionCount = pickSessionCount(
-    errorContext.sessionCount,
-    errorContext.session_count,
-    errorContext.context?.sessionCount,
-    errorContext.context?.session_count,
-  );
-  const session_ids = normalizeSessionIds(
-    sessionId ? [...current.session_ids, sessionId] : current.session_ids,
-  );
-  return {
-    ...current,
-    project_slug: pickString(
-      pickProjectSlug(errorContext),
-      current.project_slug,
-    ),
-    session_ids,
-    session_occurrences: Math.max(
-      current.session_occurrences,
-      session_ids.length,
-    ),
-    last_seen_session: Math.max(current.last_seen_session, sessionCount),
-    last_decay_session: current.last_decay_session || sessionCount,
-  };
-}
-
 function filterEntriesByType(entries, type) {
   return entries.filter(
     (entry) => (entry.type || DEFAULT_REFLEXION_TYPE) === type,