triflux 10.41.1 → 10.43.0

package/hub/bridge.mjs

@@ -99,6 +99,11 @@ const HUB_OPERATIONS = Object.freeze({
     action: "register",
     httpPath: "/bridge/register",
   },
+  heartbeat: {
+    transport: "command",
+    action: "heartbeat",
+    httpPath: "/bridge/heartbeat",
+  },
   result: {
     transport: "command",
     action: "result",
@@ -637,6 +642,14 @@ async function cmdRegister(args) {
   return emitJson(result || unavailableResult());
 }
 
+async function cmdHeartbeat(args) {
+  const outcome = await requestHub(HUB_OPERATIONS.heartbeat, {
+    agent_id: args.agent,
+    ttl_ms: args["ttl-ms"] != null ? Number(args["ttl-ms"]) : undefined,
+  });
+  return emitJson(outcome?.result || unavailableResult());
+}
+
 async function cmdResult(args) {
   let output = "";
   if (args.file && existsSync(args.file)) {
@@ -1559,6 +1572,68 @@ async function cmdRetryStatus(args) {
   return true;
 }
 
+// intervene-run은 hub transport를 거치지 않는다. heartbeat가 hub 장애 중에도
+// process/daemon/pane 사다리를 실행할 수 있도록 순수 로컬 모듈만 호출한다.
+async function cmdInterveneRun(args) {
+  try {
+    const payload = readBridgePayload(args);
+    const intervention = await import("./team/intervention.mjs");
+    let rolloutFile = payload.rolloutFile || null;
+    if (!rolloutFile && payload.cli === "codex" && payload.pid) {
+      rolloutFile = await intervention.resolveCodexRolloutFile({
+        pid: numericOption(payload.pid, undefined),
+        codexHome: payload.codexHome,
+      });
+    }
+    const seconds = (value) => {
+      const parsed = numericOption(value, undefined);
+      return parsed > 0 ? parsed * 1_000 : undefined;
+    };
+    const readActivitySignature = intervention.createFileActivitySource({
+      files: [payload.stdoutLog, payload.stderrLog, payload.resultFile].filter(
+        Boolean,
+      ),
+      rolloutFile,
+    });
+    const ladder = intervention.createInterventionLadder({
+      target: {
+        channel: payload.channel,
+        pid: numericOption(payload.pid, undefined),
+        paneId: payload.paneId,
+        interactive: payload.interactive === true,
+        cli: payload.cli,
+        sessionId: payload.sessionId,
+        codexHome: payload.codexHome,
+        rolloutFile,
+        daemon: payload.daemon,
+      },
+      reinstructPrompt: payload.reinstructPrompt || undefined,
+      readActivitySignature,
+      config: {
+        ...(seconds(payload.reinstructWaitSec)
+          ? { reinstructWaitMs: seconds(payload.reinstructWaitSec) }
+          : {}),
+        ...(seconds(payload.resumeWaitSec)
+          ? { resumeWaitMs: seconds(payload.resumeWaitSec) }
+          : {}),
+        ...(seconds(payload.sigtermGraceSec)
+          ? { sigtermGraceMs: seconds(payload.sigtermGraceSec) }
+          : {}),
+      },
+      log: (event) =>
+        process.stderr.write(`[tfx-intervene] ${JSON.stringify(event)}\n`),
+    });
+    return emitJson(await ladder.intervene());
+  } catch (error) {
+    return emitJson({
+      ok: false,
+      outcome: "failed",
+      step: null,
+      error: error?.message || String(error),
+    });
+  }
+}
+
 export async function main(argv = process.argv.slice(2)) {
   const cmd = argv[0];
   const args = parseArgs(argv.slice(1));
@@ -1566,6 +1641,8 @@ export async function main(argv = process.argv.slice(2)) {
   switch (cmd) {
     case "register":
       return await cmdRegister(args);
+    case "heartbeat":
+      return await cmdHeartbeat(args);
     case "result":
       return await cmdResult(args);
     case "control":
@@ -1630,9 +1707,11 @@ export async function main(argv = process.argv.slice(2)) {
       return await cmdRetryRun(args);
     case "retry-status":
       return await cmdRetryStatus(args);
+    case "intervene-run":
+      return await cmdInterveneRun(args);
     default:
       console.error(
-        "사용법: bridge.mjs <register|result|control|handoff|publish|takeover-role|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|daemon-probe|daemon-attach|daemon-interrupt|retry-run|retry-status> [--옵션]",
+        "사용법: bridge.mjs <register|heartbeat|result|control|handoff|publish|takeover-role|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|daemon-probe|daemon-attach|daemon-interrupt|retry-run|retry-status|intervene-run> [--옵션]",
       );
       process.exit(1);
   }

package/hub/cli-adapter-base.mjs

@@ -6,7 +6,14 @@ import { existsSync, readFileSync, statSync } from "node:fs";
 
 import { codexProfileConfigOverrides } from "../scripts/lib/codex-profile-config.mjs";
 import { writePromptToTmpFile } from "./lib/prompt-tmp.mjs";
+import {
+  createActivityLifecycle,
+  isActivityLifecycleEnabled,
+  resolveHardCeilingMs,
+  resolveStallInterventionMs,
+} from "./lib/worker-lifecycle.mjs";
 import { IS_WINDOWS, killProcess } from "./platform.mjs";
+import { createInterventionLadder } from "./team/intervention.mjs";
 
 // ── Quota retry-after 파싱 ──────────────────────────────────────
 
@@ -397,19 +404,36 @@ export async function terminateChild(pid, opts = {}) {
  *
  * @param {string} command — shell command to run
  * @param {string} workdir — cwd for the child process
- * @param {number} timeout — max duration in ms
+ * @param {number} timeout — legacy wall-clock duration (TFX_ACTIVITY_LIFECYCLE=0 only)
  * @param {object} [opts]
  * @param {string} [opts.resultFile] — file to read output from (if CLI writes there)
  * @param {function} [opts.inferStallMode] — (stdout, stderr) => string. Default: () => 'timeout'
  * @param {number} [opts.stallCheckIntervalMs] — stall check interval (default 10_000)
- * @param {number} [opts.stallThresholdMs] — stall threshold (default 30_000)
+ * @param {number} [opts.stallThresholdMs] — inactivity threshold
+ * @param {number} [opts.hardCeilingMs] — activity-independent maximum duration
+ * @param {(context: object) => Promise<boolean|string>|boolean|string} [opts.onStallIntervene]
+ *   T5 intervention seam; true or "resolved" keeps the process alive
+ * @param {object} [opts.deps] — clock/process/timer overrides for deterministic tests
  * @returns {Promise<object>} createResult-shaped object
  */
 export async function runProcess(command, workdir, timeout, opts = {}) {
-  const startedAt = Date.now();
+  const deps = opts.deps || {};
+  const now = deps.now || Date.now;
+  const spawnProcess = deps.spawn || spawn;
+  const scheduleTimeout = deps.setTimeout || setTimeout;
+  const cancelTimeout = deps.clearTimeout || clearTimeout;
+  const scheduleInterval = deps.setInterval || setInterval;
+  const cancelInterval = deps.clearInterval || clearInterval;
+  const terminateProcess = deps.terminateChild || terminateChild;
+  const startedAt = now();
   const inferStallMode = opts.inferStallMode || (() => "timeout");
   const stallCheckIntervalMs = opts.stallCheckIntervalMs ?? 10_000;
-  const stallThresholdMs = opts.stallThresholdMs ?? 30_000;
+  const legacyLifecycle = !isActivityLifecycleEnabled();
+  const stallThresholdMs =
+    opts.stallThresholdMs ??
+    (legacyLifecycle ? 30_000 : resolveStallInterventionMs());
+  const hardCeilingMs = opts.hardCeilingMs ?? resolveHardCeilingMs();
+  const earlyClassifyMs = opts.earlyClassifyMs ?? 30_000;
   const resultFile = opts.resultFile || null;
 
   let stdout = "";
@@ -421,7 +445,7 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
   try {
     // PRD A1: opts.spawnEnv 가 있으면 그 env 로 spawn (lease 의 authFile/env 적용).
     // undefined 면 spawn 의 default 동작 (부모 process env inherit) 유지.
-    child = spawn(command, {
+    child = spawnProcess(command, {
       cwd: workdir,
       shell: true,
       windowsHide: true,
@@ -430,7 +454,7 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
   } catch (error) {
     return createResult(false, {
       stderr: String(error?.message || error),
-      duration: Date.now() - startedAt,
+      duration: now() - startedAt,
     });
   }
 
@@ -446,9 +470,40 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
 
   let lastBytes = 0;
   let lastResultFileSignature = resultFileSignature();
-  let lastChange = Date.now();
+  let lastChange = now();
+  const activitySignature = () =>
+    `${Buffer.byteLength(stdout) + Buffer.byteLength(stderr)}:${resultFileSignature()}`;
+  let ladder = null;
+  const lifecycle = createActivityLifecycle({
+    enabled: !legacyLifecycle,
+    interventionMs: stallThresholdMs,
+    hardCeilingMs,
+    now,
+    onIntervene: async (context) => {
+      if (typeof opts.onStallIntervene === "function") {
+        const result = await opts.onStallIntervene(context);
+        return result === true || result === "resolved";
+      }
+      ladder ??= createInterventionLadder({
+        target: {
+          pid: child.pid,
+          cli: opts.cli,
+          codexHome: opts.codexHome,
+          rolloutFile: opts.rolloutFile,
+        },
+        readActivitySignature: activitySignature,
+        deps:
+          typeof opts.resumeHandler === "function"
+            ? { resumeHandler: opts.resumeHandler }
+            : {},
+      });
+      const result = await ladder.intervene();
+      return result?.outcome === "reactivated" || result?.outcome === "resumed";
+    },
+  });
   const touch = () => {
-    lastChange = Date.now();
+    lastChange = now();
+    lifecycle.observe(activitySignature());
   };
   child.stdout?.on("data", (chunk) => {
     stdout += String(chunk);
@@ -466,13 +521,15 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
   const stopFor = async (mode) => {
     if (failureMode) return;
     failureMode = mode;
-    await terminateChild(child.pid);
+    await terminateProcess(child.pid);
   };
 
-  const timeoutTimer = setTimeout(() => {
-    void stopFor("timeout");
-  }, timeout);
-  const stallTimer = setInterval(() => {
+  const timeoutTimer = legacyLifecycle
+    ? scheduleTimeout(() => {
+        void stopFor("timeout");
+      }, timeout)
+    : null;
+  const stallTimer = scheduleInterval(() => {
     const size = Buffer.byteLength(stdout) + Buffer.byteLength(stderr);
     const currentResultFileSignature = resultFileSignature();
     if (
@@ -482,13 +539,37 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
       lastBytes = size;
       lastResultFileSignature = currentResultFileSignature;
       touch();
+    }
+    if (legacyLifecycle) {
+      if (now() - lastChange >= stallThresholdMs)
+        void stopFor(inferStallMode(stdout, stderr));
       return;
     }
-    if (Date.now() - lastChange >= stallThresholdMs)
+    const quietMs = now() - lastChange;
+    const mode = inferStallMode(stdout, stderr);
+    if (
+      quietMs >= earlyClassifyMs &&
+      (mode === "rate_limited" || mode === "auth_stall")
+    ) {
       void stopFor(inferStallMode(stdout, stderr));
+      return;
+    }
+    void lifecycle
+      .check({
+        pid: child.pid,
+        command,
+        workdir,
+        mode,
+        stdoutTail: stdout.slice(-2000),
+        stderrTail: stderr.slice(-2000),
+      })
+      .then((reason) => {
+        if (!reason) return;
+        void stopFor(reason === "hard_ceiling" ? "timeout" : mode);
+      });
   }, stallCheckIntervalMs);
-  timeoutTimer.unref?.();
-  stallTimer.unref?.();
+  timeoutTimer?.unref?.();
+  stallTimer?.unref?.();
 
   await new Promise((resolve) =>
     child.on("close", (code) => {
@@ -496,8 +577,8 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
       resolve();
     }),
   );
-  clearTimeout(timeoutTimer);
-  clearInterval(stallTimer);
+  if (timeoutTimer) cancelTimeout(timeoutTimer);
+  cancelInterval(stallTimer);
 
   const fileOutput =
     resultFile && existsSync(resultFile)
@@ -509,7 +590,7 @@ export async function runProcess(command, workdir, timeout, opts = {}) {
     output,
     stderr,
     exitCode,
-    duration: Date.now() - startedAt,
+    duration: now() - startedAt,
     failureMode: ok ? null : failureMode || "crash",
   });
 }

package/hub/codex-adapter.mjs

@@ -11,6 +11,7 @@ import {
   shellQuote,
 } from "./cli-adapter-base.mjs";
 import { runPreflight } from "./codex-preflight.mjs";
+import { isActivityLifecycleEnabled } from "./lib/worker-lifecycle.mjs";
 
 // ── Codex-specific stall inference ──────────────────────────────
 
@@ -64,9 +65,10 @@ function buildAttempts(opts, preflight) {
     forceBypass: preflight.needsBypass,
   };
   if (opts.retryOnFail === false) return [base];
+  const retryTimeout = isActivityLifecycleEnabled() ? timeout : timeout * 2;
   return [
     base,
-    { ...base, timeout: timeout * 2, excluded: requested, forceBypass: true },
+    { ...base, timeout: retryTimeout, excluded: requested, forceBypass: true },
   ];
 }
 
@@ -183,6 +185,8 @@ async function runCodex(prompt, workdir, preflight, attempt, lease) {
     resultFile,
     inferStallMode,
     spawnEnv,
+    cli: "codex",
+    codexHome: spawnEnv?.CODEX_HOME,
   });
 }
 

package/hub/dynamic-routing-engine.mjs

@@ -45,7 +45,7 @@ function makeFallback(policy, trigger, inputsHash, now) {
       {
         cli: fb.default_cli ?? "codex",
         accountId: null,
-        model: fb.default_model ?? "gpt-5.5",
+        model: fb.default_model ?? "gpt-5.6-terra",
         riskTier: "safe",
         reason: trigger,
       },

package/hub/gemini-adapter.mjs

@@ -9,6 +9,7 @@ import {
   normalizePathForShell,
   runProcess,
 } from "./cli-adapter-base.mjs";
+import { isActivityLifecycleEnabled } from "./lib/worker-lifecycle.mjs";
 import { whichCommandAsync } from "./platform.mjs";
 
 function shellSingleQuote(value) {
@@ -88,7 +89,8 @@ function buildAttempts(opts, preflight) {
     excludeMcpServers: [...(preflight.excludeMcpServers || [])],
   };
   if (opts.retryOnFail === false) return [base];
-  return [base, { ...base, timeout: timeout * 2, allowedMcpServers: [] }];
+  const retryTimeout = isActivityLifecycleEnabled() ? timeout : timeout * 2;
+  return [base, { ...base, timeout: retryTimeout, allowedMcpServers: [] }];
 }
 
 // ── Public: buildExecArgs ───────────────────────────────────────

package/hub/intent.mjs

@@ -62,21 +62,25 @@ function _tryCodexClassify(prompt) {
  */
 export const INTENT_CATEGORIES = {
   // 모델 정책 (2026-04-25):
-  // - gpt-5.5 = 메인 (코드 포함 모든 메인 직무, fast tier 가능)
+  // - GPT-5.6 family = 기존 semantic tier를 Sol/Terra/Luna lane으로 매핑
   // - gpt-5.4-mini = 자잘/부가/가성비 (fast tier 가능)
   // - gpt-5.3-codex = escalation 가성비 중간 (fast 미지원)
-  // - gpt-5.4 폐기, gpt-5.5 로 격상
-  implement: { agent: "executor", mcp: "implement", effort: "gpt55_high" },
-  debug: { agent: "debugger", mcp: "implement", effort: "gpt55_xhigh" },
-  analyze: { agent: "analyst", mcp: "analyze", effort: "gpt55_xhigh" },
-  design: { agent: "architect", mcp: "analyze", effort: "gpt55_xhigh" },
-  review: { agent: "code-reviewer", mcp: "review", effort: "gpt55_high" },
+  // - 기존 effort는 유지하고 모델만 GPT-5.6 family로 교체
+  implement: {
+    agent: "executor",
+    mcp: "implement",
+    effort: "gpt56_terra_high",
+  },
+  debug: { agent: "debugger", mcp: "implement", effort: "gpt56_sol_xhigh" },
+  analyze: { agent: "analyst", mcp: "analyze", effort: "gpt56_sol_xhigh" },
+  design: { agent: "architect", mcp: "analyze", effort: "gpt56_sol_xhigh" },
+  review: { agent: "code-reviewer", mcp: "review", effort: "gpt56_terra_high" },
   document: { agent: "writer", mcp: "docs", effort: "pro" },
-  research: { agent: "scientist", mcp: "analyze", effort: "gpt55_high" },
+  research: { agent: "scientist", mcp: "analyze", effort: "gpt56_terra_high" },
   "quick-fix": {
     agent: "build-fixer",
     mcp: "implement",
-    effort: "gpt55_low",
+    effort: "gpt56_luna_low",
   },
   explain: { agent: "writer", mcp: "docs", effort: "flash" },
   test: { agent: "test-engineer", mcp: null, effort: null },

package/hub/lib/cto-env.mjs

@@ -0,0 +1,94 @@
+const OFF_VALUES = new Set(["0", "false", "off", "no"]);
+const ON_VALUES = new Set(["1", "true", "on", "yes"]);
+
+function normalizeEnvValue(name) {
+  return String(process.env[name] ?? "")
+    .trim()
+    .toLowerCase();
+}
+
+function isExplicitlyOff(name) {
+  return OFF_VALUES.has(normalizeEnvValue(name));
+}
+
+function isExplicitlyOn(name) {
+  return ON_VALUES.has(normalizeEnvValue(name));
+}
+
+function normalizeEnv(env, name) {
+  return String(env?.[name] ?? "")
+    .trim()
+    .toLowerCase();
+}
+
+function isEnvOff(env, name) {
+  return OFF_VALUES.has(normalizeEnv(env, name));
+}
+
+function isEnvOn(env, name) {
+  return ON_VALUES.has(normalizeEnv(env, name));
+}
+
+/**
+ * Resolve the C6a control plane without mutating environment or runtime
+ * state. Callers own storing and incrementing the returned generation.
+ */
+export function resolveRoleControlSnapshot(env = process.env, options = {}) {
+  const masterEnabled = !isEnvOff(env, "TFX_CTO");
+  const ctoManagerEnabled = masterEnabled && isEnvOn(env, "TFX_CTO_MANAGER");
+  const leadManagerEnabled =
+    ctoManagerEnabled && isEnvOn(env, "TFX_LEAD_MANAGER");
+  const northStarEnabled =
+    masterEnabled && !isEnvOff(env, "TFX_CTO_NORTH_STAR");
+  const autoCollectEnabled =
+    masterEnabled && !isEnvOff(env, "TFX_CTO_AUTO_COLLECT");
+  const values = {
+    master_enabled: masterEnabled,
+    cto_manager_enabled: ctoManagerEnabled,
+    lead_manager_enabled: leadManagerEnabled,
+    north_star_enabled: northStarEnabled,
+    auto_collect_enabled: autoCollectEnabled,
+  };
+  const previous = options.previous;
+  const changed = Object.keys(values).some(
+    (field) => previous?.[field] !== values[field],
+  );
+  const generation = previous
+    ? Number(previous.generation || 0) + (changed ? 1 : 0)
+    : Number.isSafeInteger(options.generation) && options.generation >= 0
+      ? options.generation
+      : 0;
+  return { generation, ...values };
+}
+
+export function isCtoDisabled() {
+  return isExplicitlyOff("TFX_CTO");
+}
+
+export function isCtoManagerEnabled() {
+  if (isCtoDisabled()) return false;
+  return isExplicitlyOn("TFX_CTO_MANAGER");
+}
+
+export function getCtoHygieneApplyMode() {
+  if (isExplicitlyOff("TFX_CTO")) return "off";
+  return normalizeEnvValue("TFX_CTO_HYGIENE_APPLY") === "archive"
+    ? "archive"
+    : "off";
+}
+
+export function isCtoRetentionEnabled() {
+  if (isExplicitlyOff("TFX_CTO")) return false;
+  return isExplicitlyOn("TFX_CTO_RETENTION");
+}
+
+export function getCtoMode() {
+  return normalizeEnvValue("TFX_CTO_MODE") === "bridge" ? "bridge" : "bounded";
+}
+
+export function getCtoMaxTokens() {
+  const raw = normalizeEnvValue("TFX_CTO_MAX_TOKENS");
+  if (!raw) return 0;
+  const value = Number(raw);
+  return Number.isSafeInteger(value) && value > 0 ? value : 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,