@triflux/core 10.41.1 → 10.43.0

package/hub/lib/memory-store.mjs

@@ -1,6 +1,10 @@
 // hub/lib/memory-store.mjs — In-memory store (SQLite-free fallback for @triflux/core)
 
 import { recalcConfidence } from "../reflexion.mjs";
+import {
+  clampDurationMs,
+  DEFAULT_ASSIGN_TIMEOUT_MS,
+} from "./timeout-defaults.mjs";
 import { uuidv7 } from "./uuidv7.mjs";
 
 export function clone(value) {
@@ -19,12 +23,6 @@ function clampPriority(value, fallback = 5) {
   return Math.max(1, Math.min(Math.trunc(num), 9));
 }
 
-function clampDuration(value, fallback = 600000, min = 1000, max = 86400000) {
-  const num = Number(value);
-  if (!Number.isFinite(num)) return fallback;
-  return Math.max(min, Math.min(Math.trunc(num), max));
-}
-
 export function clampConfidence(value, fallback = 0.5) {
   const num = Number(value);
   if (!Number.isFinite(num)) return fallback;
@@ -177,6 +175,15 @@ export function createMemoryStore() {
         lease_id: uuidv7(),
         lease_expires_ms: next.lease_expires_ms,
         server_time_ms: now,
+        effective: {
+          updated: true,
+          online: next.status === "online",
+          status: next.status,
+          last_seen_ms: next.last_seen_ms,
+          lease_expires_ms: next.lease_expires_ms,
+          store_type: "memory",
+          db_path: null,
+        },
       };
     },
 
@@ -191,6 +198,7 @@ export function createMemoryStore() {
           agent_id: agentId,
           lease_expires_ms: Date.now() + ttlMs,
           server_time_ms: Date.now(),
+          effective: { updated: false, store_type: "memory", db_path: null },
         };
       const now = Date.now();
       current.last_seen_ms = now;
@@ -200,6 +208,7 @@ 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 },
       };
     },
 
@@ -455,9 +464,10 @@ export function createMemoryStore() {
       retry_count = 0,
       max_retries = 0,
       priority = 5,
-      ttl_ms = 600000,
-      timeout_ms = 600000,
+      ttl_ms = DEFAULT_ASSIGN_TIMEOUT_MS,
+      timeout_ms = DEFAULT_ASSIGN_TIMEOUT_MS,
       deadline_ms,
+      dispatched_at_ms = null,
       trace_id,
       correlation_id,
       last_message_id = null,
@@ -465,7 +475,10 @@ export function createMemoryStore() {
       error = null,
     }) {
       const now = Date.now();
-      const normalizedTimeout = clampDuration(timeout_ms, 600000);
+      const normalizedTimeout = clampDurationMs(
+        timeout_ms,
+        DEFAULT_ASSIGN_TIMEOUT_MS,
+      );
       const row = {
         job_id: job_id || uuidv7(),
         supervisor_agent,
@@ -478,7 +491,7 @@ export function createMemoryStore() {
         retry_count: Math.max(0, Number(retry_count) || 0),
         max_retries: Math.max(0, Number(max_retries) || 0),
         priority: clampPriority(priority, 5),
-        ttl_ms: clampDuration(ttl_ms, normalizedTimeout),
+        ttl_ms: clampDurationMs(ttl_ms, normalizedTimeout),
         timeout_ms: normalizedTimeout,
         deadline_ms: Number.isFinite(Number(deadline_ms))
           ? Math.trunc(Number(deadline_ms))
@@ -491,6 +504,10 @@ export function createMemoryStore() {
         created_at_ms: now,
         updated_at_ms: now,
         started_at_ms: status === "running" ? now : null,
+        dispatched_at_ms:
+          dispatched_at_ms == null || !Number.isFinite(Number(dispatched_at_ms))
+            ? null
+            : Math.trunc(Number(dispatched_at_ms)),
         completed_at_ms: ["succeeded", "failed", "timed_out"].includes(status)
           ? now
           : null,
@@ -515,7 +532,7 @@ export function createMemoryStore() {
       const isTerminal = ["succeeded", "failed", "timed_out"].includes(
         nextStatus,
       );
-      const nextTimeout = clampDuration(
+      const nextTimeout = clampDurationMs(
         patch.timeout_ms ?? current.timeout_ms,
         current.timeout_ms,
       );
@@ -543,7 +560,7 @@ export function createMemoryStore() {
           patch.priority ?? current.priority,
           current.priority || 5,
         ),
-        ttl_ms: clampDuration(
+        ttl_ms: clampDurationMs(
           patch.ttl_ms ?? current.ttl_ms,
           current.ttl_ms || nextTimeout,
         ),
@@ -580,6 +597,9 @@ export function createMemoryStore() {
           : nextStatus === "running"
             ? current.started_at_ms || now
             : current.started_at_ms,
+        dispatched_at_ms: Object.hasOwn(patch, "dispatched_at_ms")
+          ? patch.dispatched_at_ms
+          : current.dispatched_at_ms,
         completed_at_ms: Object.hasOwn(patch, "completed_at_ms")
           ? patch.completed_at_ms
           : isTerminal
@@ -645,7 +665,7 @@ export function createMemoryStore() {
         current.attempt + 1,
         Number(patch.attempt ?? current.attempt + 1) || 1,
       );
-      const nextTimeout = clampDuration(
+      const nextTimeout = clampDurationMs(
         patch.timeout_ms ?? current.timeout_ms,
         current.timeout_ms,
       );
@@ -657,6 +677,7 @@ export function createMemoryStore() {
         deadline_ms: Date.now() + nextTimeout,
         completed_at_ms: null,
         started_at_ms: null,
+        dispatched_at_ms: null,
         last_retry_at_ms: Date.now(),
         result: patch.result ?? null,
         error: Object.hasOwn(patch, "error") ? patch.error : current.error,

package/hub/lib/timeout-defaults.mjs

@@ -0,0 +1,45 @@
+// hub 조율 평면 타임아웃/TTL의 단일 기준값. 환경은 호출 시점에 읽는다.
+
+export const MIN_DURATION_MS = 1_000;
+export const MAX_DURATION_MS = 86_400_000;
+export const DEFAULT_ASSIGN_TIMEOUT_MS = 600_000;
+export const DEFAULT_ASSIGN_TTL_MS = 600_000;
+export const DEFAULT_HANDOFF_TTL_MS = 600_000;
+export const DEFAULT_SWARM_LOCK_TTL_MS = 600_000;
+export const DEFAULT_REGISTER_TIMEOUT_SEC = 600;
+export const REGISTER_HEARTBEAT_GRACE_MS = 120_000;
+export const DEFAULT_STALL_INTERVENTION_SEC = 1_200;
+export const DEFAULT_HARD_CEILING_SEC = 21_600;
+
+function readEnvSeconds(env, name, fallbackSec) {
+  const value = Number(env?.[name]);
+  return Number.isFinite(value) && value > 0 ? Math.trunc(value) : fallbackSec;
+}
+
+export function resolveStallInterventionMs(env = process.env) {
+  return (
+    readEnvSeconds(env, "TFX_STALL_THRESHOLD", DEFAULT_STALL_INTERVENTION_SEC) *
+    1000
+  );
+}
+
+export function resolveHardCeilingMs(env = process.env) {
+  return (
+    readEnvSeconds(env, "TFX_HARD_CEILING_SEC", DEFAULT_HARD_CEILING_SEC) * 1000
+  );
+}
+
+export function resolveWorkerLeaseTtlMs(env = process.env) {
+  return resolveStallInterventionMs(env) + REGISTER_HEARTBEAT_GRACE_MS;
+}
+
+export function clampDurationMs(
+  value,
+  fallback = DEFAULT_ASSIGN_TIMEOUT_MS,
+  min = MIN_DURATION_MS,
+  max = MAX_DURATION_MS,
+) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(Math.trunc(numeric), max));
+}

package/hub/lib/worker-lifecycle.mjs

@@ -0,0 +1,101 @@
+// 활동 기반 워커 lifecycle. 시간 기본값은 timeout-defaults SSOT에서만 가져온다.
+import {
+  resolveHardCeilingMs,
+  resolveStallInterventionMs,
+} from "./timeout-defaults.mjs";
+
+export { resolveHardCeilingMs, resolveStallInterventionMs };
+
+export function isActivityLifecycleEnabled(env = process.env) {
+  return env.TFX_ACTIVITY_LIFECYCLE !== "0";
+}
+
+/**
+ * 활동 신호를 기준으로 무활동 개입과 절대 상한을 판정한다.
+ * 호출자는 observe()에 자기 채널의 기존 활동 서명을 전달하고, check()에
+ * 개입 대상 문맥을 제공한다. 이 모듈은 신호를 생성하거나 개입을 실행하지 않는다.
+ */
+export function createActivityLifecycle({
+  enabled = isActivityLifecycleEnabled(),
+  interventionMs = resolveStallInterventionMs(),
+  hardCeilingMs = resolveHardCeilingMs(),
+  maxInterventions = 1,
+  onIntervene,
+  now = Date.now,
+} = {}) {
+  const startedAt = now();
+  let lastActivityAt = startedAt;
+  let lastSignature;
+  let hasSignature = false;
+  let interventions = 0;
+  let timeoutReason = "";
+  let pendingIntervention = null;
+
+  const markActivity = () => {
+    lastActivityAt = now();
+  };
+
+  async function intervene(context = {}) {
+    if (!enabled || typeof onIntervene !== "function") return false;
+    if (interventions >= maxInterventions || pendingIntervention) return false;
+
+    interventions += 1;
+    const inactiveMs = Math.max(0, now() - lastActivityAt);
+    pendingIntervention = Promise.resolve(
+      onIntervene({ ...context, inactiveMs, interventions }),
+    )
+      .then((handled) => handled === true)
+      .catch(() => false);
+    try {
+      const handled = await pendingIntervention;
+      if (handled) markActivity();
+      return handled;
+    } finally {
+      pendingIntervention = null;
+    }
+  }
+
+  return Object.freeze({
+    observe(...args) {
+      if (!enabled) return false;
+      const [signature] = args;
+      const changed =
+        args.length === 0 || !hasSignature || signature !== lastSignature;
+      if (changed) {
+        lastSignature = signature;
+        hasSignature = true;
+        markActivity();
+      }
+      return changed;
+    },
+    async check(context = {}) {
+      if (!enabled || timeoutReason) return timeoutReason;
+      const current = now();
+      if (current - startedAt >= hardCeilingMs) {
+        timeoutReason = "hard_ceiling";
+        return timeoutReason;
+      }
+      if (current - lastActivityAt < interventionMs || pendingIntervention)
+        return "";
+      if (await intervene(context)) return "";
+      timeoutReason = "inactivity";
+      return timeoutReason;
+    },
+    intervene,
+    get enabled() {
+      return enabled;
+    },
+    get hardCeilingMs() {
+      return hardCeilingMs;
+    },
+    get interventionMs() {
+      return interventionMs;
+    },
+    get interventions() {
+      return interventions;
+    },
+    get timeoutReason() {
+      return timeoutReason;
+    },
+  });
+}