@triflux/remote 10.1.0 → 10.25.1

package/hub/team/health-probe.mjs

@@ -2,6 +2,10 @@
 // 기존 cli-adapter-base.mjs:stallThresholdMs(30s)와 headless.mjs:STALL_DEFAULTS(120s)를
 // 4단계 probe 모델로 교체. stdout+stderr 통합 스트림으로 평가 (F3 해결).
 
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+
 /**
  * Health probe level 정의.
  * L0: Process alive (PID 존재 + exit code 없음)
@@ -11,10 +15,10 @@
  * L3: Prompt acknowledged (첫 tool call/텍스트, 120s)
  */
 export const PROBE_LEVELS = Object.freeze({
-  L0: 'alive',
-  L1: 'advancing',
-  L2: 'mcp_connected',
-  L3: 'prompt_ack',
+  L0: "alive",
+  L1: "advancing",
+  L2: "mcp_connected",
+  L3: "prompt_ack",
 });
 
 /** 기본 설정 (기존 stallThresholdMs/stallTimeout 값 계승) */
@@ -24,7 +28,12 @@ export const PROBE_DEFAULTS = Object.freeze({
   l1ThresholdMs: 30_000,
   l2ThresholdMs: 30_000,
   l3ThresholdMs: 120_000,
-  enableL2: false,
+  // #168 P3: default off → on. checkMcp 미주입 시에도 probeL2 가 skip 반환하므로
+  // safe. conductor wiring 이 checkMcp 를 주입하면 실제 L2 판정이 활성화된다.
+  // opt-out: TFX_PROBE_L2=0 (conductor 에서 false 주입).
+  enableL2: true,
+  writeStateFile: false,
+  stateDir: join(tmpdir(), "tfx-probe"),
 });
 
 /**
@@ -32,13 +41,13 @@ export const PROBE_DEFAULTS = Object.freeze({
  * Codex가 질문하며 stdin을 기다리는 경우 stall이 아니라 INPUT_WAIT로 분류.
  */
 const INPUT_WAIT_PATTERNS = [
-  /\?\s*$/m,                          // 물음표로 끝나는 줄
-  /\b(y\/n|yes\/no)\b/i,             // y/n 프롬프트
-  /\b(choose|select|pick)\b.*:/i,    // choose/select 프롬프트
-  /\b(confirm|approve|proceed)\b/i,  // confirm 프롬프트
-  /\b(enter|input|type)\b.*:/i,      // 입력 요청
-  /\[.*\]:\s*$/m,                     // [default]: 형태
-  />\s*$/m,                           // > 프롬프트
+  /\?\s*$/m, // 물음표로 끝나는 줄
+  /\b(y\/n|yes\/no)\b/i, // y/n 프롬프트
+  /\b(choose|select|pick)\b.*:/i, // choose/select 프롬프트
+  /\b(confirm|approve|proceed)\b/i, // confirm 프롬프트
+  /\b(enter|input|type)\b.*:/i, // 입력 요청
+  /\[.*\]:\s*$/m, // [default]: 형태
+  />\s*$/m, // > 프롬프트
 ];
 
 /**
@@ -49,7 +58,11 @@ const INPUT_WAIT_PATTERNS = [
 export function detectInputWait(recentOutput) {
   if (!recentOutput) return { detected: false, pattern: null };
   // 마지막 5줄만 검사 (전체 output이 아닌 최근 출력)
-  const lines = recentOutput.split(/\r?\n/).filter(Boolean).slice(-5).join('\n');
+  const lines = recentOutput
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .slice(-5)
+    .join("\n");
   for (const re of INPUT_WAIT_PATTERNS) {
     if (re.test(lines)) {
       return { detected: true, pattern: re.source };
@@ -74,6 +87,16 @@ export function createHealthProbe(session, opts = {}) {
   const config = { ...PROBE_DEFAULTS, ...opts };
   let timer = null;
   let started = false;
+  // stopped flag는 in-flight probe()가 stop() 사이의 await 점에서
+  // writeState/unlink 와 race 하는 것을 막는다. start() 시 false 로 reset.
+  let stopped = false;
+  // P0 (#167 review): start() 마다 증가. probe() 가 시작 시 캡처 → writeState() 가 epoch
+  // 비교로 stop()→start() 사이의 in-flight 가 새 run 의 state 를 덮는 race 차단.
+  // stopped flag 만으로는 start() 가 stopped=false 로 reset 한 직후 race 못 막음.
+  let runEpoch = 0;
+  // P1-1 (#167 review): Set 으로 모든 in-flight probe 추적. interval 이 빨라 N+1 이 N 끝나기
+  // 전에 시작되면 단일 var 는 N 을 덮어써 stopAndDrain() 시 N 이 누락된다.
+  const inFlightProbes = new Set();
 
   // L1 tracking
   let lastOutputBytes = 0;
@@ -84,22 +107,114 @@ export function createHealthProbe(session, opts = {}) {
   let spawnedAt = Date.now();
 
   const status = {
-    l0: null,  // 'ok' | 'fail'
-    l1: null,  // 'ok' | 'stall' | 'input_wait'
-    l2: null,  // 'ok' | 'fail' | 'skip'
-    l3: null,  // 'ok' | 'timeout'
+    l0: null, // 'ok' | 'fail'
+    l1: null, // 'ok' | 'stall' | 'input_wait'
+    l2: null, // 'ok' | 'fail' | 'skip'
+    l3: null, // 'ok' | 'timeout'
     lastProbeAt: null,
     inputWaitPattern: null,
   };
 
+  function getStateFilePath() {
+    if (typeof config.stateFile === "string" && config.stateFile.length > 0) {
+      return config.stateFile;
+    }
+    const pid = session.pid;
+    if (pid == null || pid <= 0) return null;
+    return join(config.stateDir, `${pid}.json`);
+  }
+
+  function deriveState(result) {
+    if (result.l0 === "fail") return "exited";
+    if (result.l1 === "input_wait") return "input_wait";
+    if (result.l2 === "fail") return "mcp_initializing";
+    if (result.l1 === "stall") return "stalled";
+    if (result.l3 === "timeout") return "reasoning";
+    return "active";
+  }
+
+  function writeState(result, probeEpoch) {
+    // stop() 직후 in-flight probe()의 재생성 방지.
+    // P0 (#167): probeEpoch !== runEpoch 면 이전 run 의 stale probe 가 새 run 의 state 를
+    // 덮으려는 시도 → skip.
+    if (stopped) return;
+    if (probeEpoch !== undefined && probeEpoch !== runEpoch) return;
+    if (!config.writeStateFile && !config.stateFile) return;
+    const stateFile = getStateFilePath();
+    if (!stateFile) return;
+    const payload =
+      JSON.stringify(
+        {
+          pid: session.pid ?? null,
+          state: deriveState(result),
+          result,
+          updatedAt: new Date(result.ts).toISOString(),
+        },
+        null,
+        2,
+      ) + "\n";
+    // tmp+rename 으로 atomic write — heartbeat 의 sed 가 부분 파일을 읽는 race 제거.
+    // tmp 는 같은 디렉토리에 둬야 EXDEV (cross-device link) 가 안 난다.
+    const tmpPath = `${stateFile}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    try {
+      mkdirSync(dirname(stateFile), { recursive: true });
+      writeFileSync(tmpPath, payload, "utf8");
+      try {
+        renameSync(tmpPath, stateFile);
+      } catch (renameErr) {
+        // Windows: 대상이 존재할 때 EPERM/EACCES.
+        // P1-2 (#167 review): backup-then-swap 으로 기존 파일 보존. 옛 unlinkSync→renameSync
+        // 패턴은 1차 unlink 후 2차 rename 실패 시 기존 파일과 tmp 둘 다 잃었다.
+        if (
+          renameErr?.code === "EEXIST" ||
+          renameErr?.code === "EPERM" ||
+          renameErr?.code === "EACCES"
+        ) {
+          const backupPath = `${stateFile}.old-${process.pid}-${Date.now()}`;
+          let backupCreated = false;
+          try {
+            renameSync(stateFile, backupPath);
+            backupCreated = true;
+          } catch {
+            // backup 실패 (대상 없음/잠김) — 그래도 진행 (tmp→stateFile 시도)
+          }
+          try {
+            renameSync(tmpPath, stateFile);
+            if (backupCreated) {
+              try {
+                unlinkSync(backupPath);
+              } catch {}
+            }
+          } catch (secondErr) {
+            // 2차도 실패 → backup 복구해서 기존 파일 보존
+            if (backupCreated) {
+              try {
+                renameSync(backupPath, stateFile);
+              } catch {}
+            }
+            throw secondErr;
+          }
+        } else {
+          throw renameErr;
+        }
+      }
+    } catch {
+      // probe state is advisory only — tmp cleanup
+      try {
+        unlinkSync(tmpPath);
+      } catch {}
+    }
+  }
+
   /**
    * L0: Process alive check.
    */
   function probeL0() {
-    const alive = session.alive !== undefined
-      ? session.alive
-      : (session.pid != null && session.pid > 0);
-    status.l0 = alive ? 'ok' : 'fail';
+    const alive =
+      session.alive !== undefined
+        ? session.alive
+        : session.pid != null && session.pid > 0;
+    status.l0 = alive ? "ok" : "fail";
     return status.l0;
   }
 
@@ -107,43 +222,45 @@ export function createHealthProbe(session, opts = {}) {
    * L1 + L1.5: Output advancing + INPUT_WAIT 감지.
    */
   function probeL1() {
-    const currentBytes = typeof session.getOutputBytes === 'function'
-      ? session.getOutputBytes()
-      : 0;
+    const currentBytes =
+      typeof session.getOutputBytes === "function"
+        ? session.getOutputBytes()
+        : 0;
 
     const now = Date.now();
 
     if (currentBytes !== lastOutputBytes) {
       lastOutputBytes = currentBytes;
       lastOutputChangeAt = now;
-      status.l1 = 'ok';
+      status.l1 = "ok";
       status.inputWaitPattern = null;
-      return 'ok';
+      return "ok";
     }
 
     const silenceMs = now - lastOutputChangeAt;
 
     if (silenceMs >= config.l1ThresholdMs) {
       // L1.5: INPUT_WAIT 감지 — stall 전에 질문 패턴 체크
-      const recentOutput = typeof session.getRecentOutput === 'function'
-        ? session.getRecentOutput()
-        : '';
+      const recentOutput =
+        typeof session.getRecentOutput === "function"
+          ? session.getRecentOutput()
+          : "";
       const inputWait = detectInputWait(recentOutput);
 
       if (inputWait.detected) {
-        status.l1 = 'input_wait';
+        status.l1 = "input_wait";
         status.inputWaitPattern = inputWait.pattern;
-        return 'input_wait';
+        return "input_wait";
       }
 
-      status.l1 = 'stall';
+      status.l1 = "stall";
       status.inputWaitPattern = null;
-      return 'stall';
+      return "stall";
     }
 
     // 아직 threshold 미달
-    status.l1 = 'ok';
-    return 'ok';
+    status.l1 = "ok";
+    return "ok";
   }
 
   /**
@@ -151,23 +268,26 @@ export function createHealthProbe(session, opts = {}) {
    */
   async function probeL2() {
     if (!config.enableL2) {
-      status.l2 = 'skip';
-      return 'skip';
+      status.l2 = "skip";
+      return "skip";
     }
-    if (typeof config.checkMcp !== 'function') {
-      status.l2 = 'skip';
-      return 'skip';
+    if (typeof config.checkMcp !== "function") {
+      status.l2 = "skip";
+      return "skip";
     }
     try {
       const connected = await Promise.race([
         config.checkMcp(),
         new Promise((_, reject) =>
-          setTimeout(() => reject(new Error('probe_timeout')), config.probeTimeoutMs)
+          setTimeout(
+            () => reject(new Error("probe_timeout")),
+            config.probeTimeoutMs,
+          ),
         ),
       ]);
-      status.l2 = connected ? 'ok' : 'fail';
+      status.l2 = connected ? "ok" : "fail";
     } catch {
-      status.l2 = 'fail';
+      status.l2 = "fail";
     }
     return status.l2;
   }
@@ -178,24 +298,25 @@ export function createHealthProbe(session, opts = {}) {
    */
   function probeL3() {
     if (promptAcked) {
-      status.l3 = 'ok';
-      return 'ok';
+      status.l3 = "ok";
+      return "ok";
     }
 
-    const currentBytes = typeof session.getOutputBytes === 'function'
-      ? session.getOutputBytes()
-      : 0;
+    const currentBytes =
+      typeof session.getOutputBytes === "function"
+        ? session.getOutputBytes()
+        : 0;
 
     if (currentBytes > 0) {
       promptAcked = true;
-      status.l3 = 'ok';
-      return 'ok';
+      status.l3 = "ok";
+      return "ok";
     }
 
     const elapsed = Date.now() - spawnedAt;
     if (elapsed >= config.l3ThresholdMs) {
-      status.l3 = 'timeout';
-      return 'timeout';
+      status.l3 = "timeout";
+      return "timeout";
     }
 
     status.l3 = null; // 아직 판정 전
@@ -204,35 +325,52 @@ export function createHealthProbe(session, opts = {}) {
 
   /**
    * 전체 probe 실행 (L0→L1→L2→L3).
-   * @returns {Promise<object>} probe 결과
+   * @returns {Promise<object|null>} probe 결과. stop() 이후 호출이면 null.
    */
   async function probe() {
-    const result = {
-      l0: probeL0(),
-      l1: probeL1(),
-      l2: await probeL2(),
-      l3: probeL3(),
-      inputWaitPattern: status.inputWaitPattern,
-      ts: Date.now(),
-    };
-    status.lastProbeAt = result.ts;
-
-    if (typeof config.onProbe === 'function') {
-      config.onProbe(result);
-    }
+    if (stopped) return null;
+    // P0 (#167): probe 시작 시 epoch 캡처. start() 가 새 epoch 로 바꾸면 이 probe 의
+    // writeState 는 stale 로 판정 → skip.
+    const probeEpoch = runEpoch;
+    const promise = (async () => {
+      const result = {
+        l0: probeL0(),
+        l1: probeL1(),
+        l2: await probeL2(),
+        l3: probeL3(),
+        inputWaitPattern: status.inputWaitPattern,
+        ts: Date.now(),
+      };
+      status.lastProbeAt = result.ts;
+      writeState(result, probeEpoch);
+
+      if (typeof config.onProbe === "function") {
+        config.onProbe(result);
+      }
 
-    return result;
+      return result;
+    })();
+    // P1-1 (#167): Set 으로 모든 in-flight 추적. 단일 var 패턴은 N+1 이 N 끝나기 전에
+    // 시작되면 N 을 덮어써 stopAndDrain() 시 N 이 누락된다.
+    inFlightProbes.add(promise);
+    promise.finally(() => inFlightProbes.delete(promise));
+    return promise;
   }
 
   function start() {
     if (started) return;
     started = true;
+    stopped = false;
+    // P0 (#167): epoch 증가 — 이전 run 의 in-flight probe 가 새 run 의 state 를 덮지 못하게.
+    runEpoch += 1;
     spawnedAt = Date.now();
     lastOutputChangeAt = Date.now();
     lastOutputBytes = 0;
     promptAcked = false;
 
-    timer = setInterval(() => { void probe(); }, config.intervalMs);
+    timer = setInterval(() => {
+      void probe();
+    }, config.intervalMs);
     timer.unref?.();
 
     // 즉시 첫 probe 실행
@@ -242,10 +380,32 @@ export function createHealthProbe(session, opts = {}) {
   function stop() {
     if (!started) return;
     started = false;
+    // stopped 를 먼저 set 해야 in-flight probe()의 writeState() 가 skip 된다.
+    // 이후 unlink — in-flight 가 끝나도 writeState 가 no-op 이므로 재생성 없음.
+    stopped = true;
     if (timer) {
       clearInterval(timer);
       timer = null;
     }
+    if (config.writeStateFile || config.stateFile) {
+      try {
+        const stateFile = getStateFilePath();
+        if (stateFile) unlinkSync(stateFile);
+      } catch {}
+    }
+  }
+
+  /**
+   * stop() 후 in-flight probe() 가 완료될 때까지 대기.
+   * 결정적 종료가 필요한 테스트/teardown 용. conductor 의 sync stop() 호출자는
+   * 그대로 stop() 만 호출하면 stopped flag 가 race 를 막는다.
+   */
+  async function stopAndDrain() {
+    stop();
+    // P1-1 (#167): 모든 in-flight probe 대기. allSettled 로 unhandled rejection 방지.
+    if (inFlightProbes.size > 0) {
+      await Promise.allSettled(Array.from(inFlightProbes));
+    }
   }
 
   /** L1 tracking 리셋 (restart 후 호출) */
@@ -264,9 +424,12 @@ export function createHealthProbe(session, opts = {}) {
   return Object.freeze({
     start,
     stop,
+    stopAndDrain,
     probe,
     resetTracking,
     getStatus: () => ({ ...status }),
-    get started() { return started; },
+    get started() {
+      return started;
+    },
   });
 }

package/hub/team/launcher-template.mjs

@@ -5,28 +5,28 @@
 // F4 해결: codex exec "prompt" 인라인 (파이프/리다이렉트 아님)
 // F5 해결: 동일 입력 → 동일 args 배열 (런타임 분기 없음)
 
-import { buildExecArgs as buildCodexArgs } from '@triflux/core/hub/codex-adapter.mjs';
-import { buildExecArgs as buildGeminiArgs } from '@triflux/core/hub/gemini-adapter.mjs';
+import { buildExecArgs as buildCodexArgs } from "@triflux/core/hub/codex-adapter.mjs";
+import { buildExecArgs as buildGeminiArgs } from "@triflux/core/hub/gemini-adapter.mjs";
 
 /** CLI별 adapter 레지스트리 */
 const ADAPTERS = Object.freeze({
   codex: {
-    bin: 'codex',
+    bin: "codex",
     buildArgs: buildCodexArgs,
     env: (profile) => (profile ? { CODEX_PROFILE: profile } : {}),
   },
   gemini: {
-    bin: 'gemini',
+    bin: "gemini",
     buildArgs: buildGeminiArgs,
     env: () => ({}),
   },
   claude: {
-    bin: 'claude',
+    bin: "claude",
     buildArgs: (opts = {}) => {
-      const parts = ['claude'];
-      if (opts.model) parts.push('--model', opts.model);
-      parts.push('-p', JSON.stringify(opts.prompt || ''));
-      return parts.join(' ');
+      const parts = ["claude"];
+      if (opts.model) parts.push("--model", opts.model);
+      parts.push("-p", JSON.stringify(opts.prompt || ""));
+      return parts.join(" ");
     },
     env: () => ({}),
   },
@@ -41,7 +41,9 @@ const ADAPTERS = Object.freeze({
 export function getAdapter(agent) {
   const adapter = ADAPTERS[agent];
   if (!adapter) {
-    throw new Error(`Unknown agent: "${agent}". Supported: ${Object.keys(ADAPTERS).join(', ')}`);
+    throw new Error(
+      `Unknown agent: "${agent}". Supported: ${Object.keys(ADAPTERS).join(", ")}`,
+    );
   }
   return adapter;
 }
@@ -60,10 +62,11 @@ export function getAdapter(agent) {
  * @returns {{ bin: string, command: string, env: object, agent: string }}
  */
 export function buildLauncher(opts) {
-  const { agent, profile, prompt, workdir, model, resultFile, mcpServers } = opts;
+  const { agent, profile, prompt, workdir, model, resultFile, mcpServers } =
+    opts;
 
-  if (!agent) throw new Error('agent is required');
-  if (!prompt && prompt !== '') throw new Error('prompt is required');
+  if (!agent) throw new Error("agent is required");
+  if (!prompt && prompt !== "") throw new Error("prompt is required");
 
   const adapter = getAdapter(agent);
 
@@ -73,7 +76,13 @@ export function buildLauncher(opts) {
     model,
     resultFile,
     workdir,
+    cwd: workdir,
     mcpServers,
+    // launcher 는 동일 입력 → 동일 명령 (F5 결정론 보장). buildExecCommand 의
+    // stdin redirect 모드는 timestamp/pid/counter 가 들어가 비결정적이라
+    // launcher path 에서는 argv-inline 모드로 강제. headless 워커 spawn 은
+    // backend.mjs → buildExecArgs (stdinPrompt 미명시) 로 default stdin on.
+    stdinPrompt: false,
   });
 
   const env = adapter.env(profile);
@@ -83,6 +92,7 @@ export function buildLauncher(opts) {
     command,
     env,
     agent,
+    cwd: workdir || null,
   });
 }
 

package/hub/team/lead-control.mjs

@@ -1,23 +1,35 @@
+import { readState } from "@triflux/core/hub/state.mjs";
+
 const DEFAULT_TIMEOUT_MS = 2500;
 const CONTROL_COMMAND_ALIASES = Object.freeze({
   stop: "abort",
   interrupt: "abort",
 });
 
-export const LEAD_CONTROL_COMMANDS = Object.freeze(["pause", "resume", "abort", "reassign"]);
+export const LEAD_CONTROL_COMMANDS = Object.freeze([
+  "pause",
+  "resume",
+  "abort",
+  "reassign",
+]);
 
 function resolveFetch(fetchImpl) {
   if (typeof fetchImpl === "function") return fetchImpl;
-  if (typeof globalThis.fetch === "function") return globalThis.fetch.bind(globalThis);
+  if (typeof globalThis.fetch === "function")
+    return globalThis.fetch.bind(globalThis);
   return null;
 }
 
 function normalizeHubBaseUrl(hubUrl) {
-  return String(hubUrl || "").replace(/\/+$/, "").replace(/\/mcp$/, "");
+  return String(hubUrl || "")
+    .replace(/\/+$/, "")
+    .replace(/\/mcp$/, "");
 }
 
 function normalizeCommand(command) {
-  const raw = String(command || "").trim().toLowerCase();
+  const raw = String(command || "")
+    .trim()
+    .toLowerCase();
   if (!raw) return "";
   return CONTROL_COMMAND_ALIASES[raw] || raw;
 }
@@ -27,6 +39,39 @@ function safeAbortSignal(timeoutMs) {
   return AbortSignal.timeout(timeoutMs);
 }
 
+function isPidAlive(pid) {
+  const resolvedPid = Number(pid);
+  if (!Number.isFinite(resolvedPid) || resolvedPid <= 0) return false;
+  try {
+    process.kill(resolvedPid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolveHeadlessHubUrl() {
+  const stateUrl = normalizeHubBaseUrl(readState()?.url);
+  if (stateUrl) return stateUrl;
+
+  const envHubUrl = normalizeHubBaseUrl(process.env.TFX_HUB_URL);
+  if (envHubUrl) return envHubUrl;
+
+  const envPort = Number(process.env.TFX_HUB_PORT || "27888");
+  const port = Number.isFinite(envPort) && envPort > 0 ? envPort : 27888;
+  return `http://127.0.0.1:${port}`;
+}
+
+function hasLiveHubState() {
+  const state = readState();
+  return !!normalizeHubBaseUrl(state?.url) && isPidAlive(state?.pid);
+}
+
+function toHeadlessSessionAgentId(sessionName) {
+  const normalizedSessionName = String(sessionName || "").trim();
+  return normalizedSessionName ? `session:${normalizedSessionName}` : "";
+}
+
 function safeJson(res) {
   return res.json().catch(() => ({}));
 }
@@ -102,3 +147,45 @@ export async function publishLeadControl({
     };
   }
 }
+
+export async function publishHeadlessControl(
+  sessionName,
+  command,
+  targetWorker = "*",
+) {
+  const sessionAgentId = toHeadlessSessionAgentId(sessionName);
+  if (!sessionAgentId) {
+    return {
+      ok: false,
+      noop: true,
+      error: "SESSION_NAME_REQUIRED",
+      command: String(command || "")
+        .trim()
+        .toLowerCase(),
+    };
+  }
+
+  if (!normalizeHubBaseUrl(process.env.TFX_HUB_URL) && !hasLiveHubState()) {
+    return {
+      ok: false,
+      noop: true,
+      error: "HUB_UNAVAILABLE",
+      command: String(command || "")
+        .trim()
+        .toLowerCase(),
+    };
+  }
+
+  return await publishLeadControl({
+    hubUrl: resolveHeadlessHubUrl(),
+    fromAgent: "lead",
+    toAgent: sessionAgentId,
+    command,
+    payload: {
+      session_name: String(sessionName || "").trim(),
+      target_worker: String(targetWorker || "*").trim() || "*",
+      issued_by: "lead",
+      issued_at: Date.now(),
+    },
+  });
+}