@triflux/core 10.44.0 → 10.45.0

package/hub/gemini-adapter.mjs

@@ -4,6 +4,10 @@
 import { mkdirSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import {
+  resolveGeminiModel,
+  resolveGeminiProfileForPurpose,
+} from "../scripts/lib/gemini-profiles.mjs";
 import {
   executeWithCircuitBroker,
   normalizePathForShell,
@@ -61,15 +65,13 @@ async function runPreflight(opts = {}) {
 // ── Command building ────────────────────────────────────────────
 
 function buildGeminiCommand(prompt, resultFile, opts = {}) {
-  const parts = [
-    "printf",
-    "%s",
-    shellSingleQuote(prompt),
-    "|",
-    "agy",
-    "--print",
-    "--dangerously-skip-permissions",
-  ];
+  // agy 의 --print 는 값(프롬프트)을 받는 플래그다. 1.1.27 부터 stdin 프롬프트는
+  // "empty prompt" 로 거부되므로 프롬프트를 --print 의 값으로, 맨 끝에 넘긴다.
+  const parts = ["agy", "--dangerously-skip-permissions"];
+  if (typeof opts.model === "string" && opts.model.trim()) {
+    parts.push("--model", shellSingleQuote(opts.model.trim()));
+  }
+  parts.push("--print", shellSingleQuote(prompt));
 
   if (resultFile) {
     return `${parts.join(" ")} > ${shellSingleQuote(normalizePathForShell(resultFile))} 2>${shellSingleQuote(normalizePathForShell(resultFile + ".err"))}`;
@@ -78,11 +80,27 @@ function buildGeminiCommand(prompt, resultFile, opts = {}) {
   return parts.join(" ");
 }
 
+function resolveAntigravityModel(opts = {}) {
+  // effort 는 역할별 SSOT(scripts/lib/gemini-profiles.mjs). 명시 model 이 우선한다.
+  const explicit = typeof opts.model === "string" ? opts.model.trim() : "";
+  if (explicit)
+    return resolveGeminiModel(explicit, {
+      profilesPath: opts.geminiProfilesPath,
+    });
+  if (!opts.role && !opts.agent) return "";
+  return resolveGeminiModel(
+    resolveGeminiProfileForPurpose(opts.role || opts.agent),
+    {
+      profilesPath: opts.geminiProfilesPath,
+    },
+  );
+}
+
 function buildAttempts(opts, preflight) {
   const timeout = Number.isFinite(opts.timeout) ? opts.timeout : 900_000;
   const base = {
     timeout,
-    model: opts.model,
+    model: resolveAntigravityModel(opts),
     allowedMcpServers: Array.isArray(opts.mcpServers)
       ? [...opts.mcpServers]
       : [],
@@ -98,7 +116,7 @@ function buildAttempts(opts, preflight) {
 export function buildExecArgs(opts = {}) {
   const prompt = typeof opts.prompt === "string" ? opts.prompt : "";
   return buildGeminiCommand(prompt, opts.resultFile || null, {
-    model: opts.model,
+    model: resolveAntigravityModel(opts),
     allowedMcpServers: opts.mcpServers,
   });
 }

package/hub/lib/memory-store.mjs

@@ -142,6 +142,7 @@ export function createMemoryStore() {
   const store = {
     type: "memory",
     db: null,
+    fingerprint: "memory:ephemeral",
     uuidv7,
 
     close() {},
@@ -166,6 +167,7 @@ export function createMemoryStore() {
         topics: clone(topics),
         last_seen_ms: now,
         lease_expires_ms: now + heartbeat_ttl_ms,
+        presence_generation: Number(current.presence_generation || 0) + 1,
         status: "online",
         metadata: clone(metadata),
       };
@@ -173,6 +175,7 @@ export function createMemoryStore() {
       return {
         agent_id,
         lease_id: uuidv7(),
+        presence_generation: next.presence_generation,
         lease_expires_ms: next.lease_expires_ms,
         server_time_ms: now,
         effective: {
@@ -183,6 +186,7 @@ export function createMemoryStore() {
           lease_expires_ms: next.lease_expires_ms,
           store_type: "memory",
           db_path: null,
+          store_fingerprint: "memory:ephemeral",
         },
       };
     },
@@ -191,14 +195,23 @@ export function createMemoryStore() {
       return clone(agents.get(id) || null);
     },
 
-    refreshLease(agentId, ttlMs = 30000) {
+    refreshLease(agentId, ttlMs = 30000, presenceGeneration) {
       const current = agents.get(agentId);
-      if (!current)
+      if (
+        !current ||
+        (presenceGeneration != null &&
+          current.presence_generation !== presenceGeneration)
+      )
         return {
           agent_id: agentId,
           lease_expires_ms: Date.now() + ttlMs,
           server_time_ms: Date.now(),
-          effective: { updated: false, store_type: "memory", db_path: null },
+          effective: {
+            updated: false,
+            store_type: "memory",
+            db_path: null,
+            store_fingerprint: "memory:ephemeral",
+          },
         };
       const now = Date.now();
       current.last_seen_ms = now;
@@ -208,7 +221,12 @@ export function createMemoryStore() {
         agent_id: agentId,
         lease_expires_ms: current.lease_expires_ms,
         server_time_ms: now,
-        effective: { updated: true, store_type: "memory", db_path: null },
+        effective: {
+          updated: true,
+          store_type: "memory",
+          db_path: null,
+          store_fingerprint: "memory:ephemeral",
+        },
       };
     },
 
@@ -243,9 +261,19 @@ export function createMemoryStore() {
 
     sweepStaleAgents() {
       const now = Date.now();
+      const candidates = Array.from(agents.values(), (agent) => ({
+        agent_id: agent.agent_id,
+        presence_generation: agent.presence_generation,
+      }));
       let stale = 0;
       let offline = 0;
-      for (const agent of agents.values()) {
+      for (const candidate of candidates) {
+        const agent = agents.get(candidate.agent_id);
+        if (
+          !agent ||
+          agent.presence_generation !== candidate.presence_generation
+        )
+          continue;
         if (agent.status === "online" && agent.lease_expires_ms < now) {
           agent.status = "stale";
           stale += 1;
@@ -260,9 +288,14 @@ export function createMemoryStore() {
       return { stale, offline };
     },
 
-    updateAgentStatus(agentId, status) {
+    updateAgentStatus(agentId, status, presenceGeneration) {
       const current = agents.get(agentId);
-      if (!current) return false;
+      if (
+        !current ||
+        (presenceGeneration != null &&
+          current.presence_generation !== presenceGeneration)
+      )
+        return false;
       current.status = status;
       return true;
     },
@@ -421,21 +454,11 @@ export function createMemoryStore() {
         .map((request) => clone(request));
     },
 
-    expireHumanRequests() {
-      let changed = 0;
-      const now = Date.now();
-      for (const request of humanRequests.values()) {
-        if (request.state === "pending" && request.deadline_ms < now) {
-          request.state = "timed_out";
-          changed += 1;
-        }
-      }
-      return changed;
-    },
-
     moveToDeadLetter(messageId, reason, lastError = null) {
       const current = messages.get(messageId);
-      if (current) current.status = "dead_letter";
+      if (!current || current.status === "dead_letter") return false;
+      current.status = "dead_letter";
+      if (deadLetters.has(messageId)) return true;
       deadLetters.set(messageId, {
         message_id: messageId,
         reason,
@@ -685,25 +708,38 @@ export function createMemoryStore() {
       });
     },
 
-    sweepExpired() {
-      const now = Date.now();
-      let expiredMessages = 0;
+    sweepExpired({ now_ms = Date.now() } = {}) {
+      const transitions = [];
       for (const message of messages.values()) {
-        if (message.status === "queued" && message.expires_at_ms < now) {
-          message.status = "dead_letter";
+        if (
+          !["queued", "delivered"].includes(message.status) ||
+          message.expires_at_ms > now_ms
+        )
+          continue;
+        const snapshot = clone(message);
+        const previousStatus = message.status;
+        message.status = "dead_letter";
+        const dlqInserted = !deadLetters.has(message.id);
+        if (dlqInserted) {
           deadLetters.set(message.id, {
             message_id: message.id,
             reason: "ttl_expired",
-            failed_at_ms: now,
+            failed_at_ms: now_ms,
             last_error: null,
           });
-          expiredMessages += 1;
         }
+        transitions.push({
+          message: snapshot,
+          previous_status: previousStatus,
+          reason: "ttl_expired",
+          failed_at_ms: now_ms,
+          dlq_inserted: dlqInserted,
+        });
       }
-      const humanRequestsExpired = store.expireHumanRequests();
       return {
-        messages: expiredMessages,
-        human_requests: humanRequestsExpired,
+        now_ms,
+        messages: transitions.length,
+        transitions,
       };
     },
 

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,