@reconcrap/boss-recommend-mcp 2.1.23 → 2.1.25

package/src/chat-mcp.js

@@ -1,8 +1,8 @@
-import fs from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
 import {
   assertNoForbiddenCdpCalls,
   bringPageToFront,
@@ -34,8 +34,10 @@ import {
   resolveChatSelfHealRoots,
   runSelfHealCheck
 } from "./core/self-heal/index.js";
-import {
-  CHAT_TARGET_URL,
+import {
+  CHAT_COLLECT_CV_PROCESSING_FLOOR_MAX_MS,
+  CHAT_COLLECT_CV_PROCESSING_FLOOR_MIN_MS,
+  CHAT_TARGET_URL,
   closeChatResumeModal,
   closeChatJobDropdown,
   createChatRunService,
@@ -54,7 +56,8 @@ import {
   resolveHumanBehaviorForRun,
   resolveBossScreeningConfig
 } from "./chat-runtime-config.js";
-import { DEFAULT_MAX_IMAGE_PAGES } from "./core/cv-acquisition/index.js";
+import { DEFAULT_MAX_IMAGE_PAGES } from "./core/cv-acquisition/index.js";
+import { launchDetachedWorker } from "./core/run/detached-launcher.js";
 
 const DEFAULT_CHAT_HOST = "127.0.0.1";
 const DEFAULT_CHAT_PORT = 9222;
@@ -85,11 +88,15 @@ const ARTIFACT_STATUSES = new Set([
   RUN_STATUS_PAUSED
 ]);
 
-const STALE_PROCESS_STATUSES = new Set([
-  "queued",
-  "running",
-  RUN_STATUS_CANCELING
-]);
+const STALE_PROCESS_STATUSES = new Set([
+  "queued",
+  "running",
+  RUN_STATUS_CANCELING
+]);
+
+const CHAT_ATOMIC_RENAME_RETRY_CODES = new Set(["EPERM", "EACCES", "EBUSY"]);
+const CHAT_ATOMIC_RENAME_RETRY_DELAYS_MS = Object.freeze([25, 50, 100, 200, 400, 500]);
+const CHAT_ATOMIC_RENAME_SLEEP_CELL = new Int32Array(new SharedArrayBuffer(4));
 
 const CHAT_REQUEST_RESUME_ACTIONS = new Set([
   "request_cv",
@@ -115,10 +122,11 @@ const CHAT_DISABLE_REQUEST_RESUME_ACTIONS = new Set([
   "不请求简历"
 ]);
 
-let chatWorkflowImpl = runChatWorkflow;
-let chatConnectorImpl = connectChatChromeSession;
-let chatJobReaderImpl = readChatJobOptionsFromSession;
-let chatRunService = createChatRunService({
+let chatWorkflowImpl = runChatWorkflow;
+let chatConnectorImpl = connectChatChromeSession;
+let chatJobReaderImpl = readChatJobOptionsFromSession;
+let chatDetachedWorkerLauncherImpl = launchDetachedWorker;
+let chatRunService = createChatRunService({
   idPrefix: "mcp_chat",
   workflow: (...args) => chatWorkflowImpl(...args),
   onSnapshot: persistChatLifecycleSnapshot
@@ -187,12 +195,60 @@ function ensureDirectory(dirPath) {
   fs.mkdirSync(dirPath, { recursive: true });
 }
 
-function writeJsonAtomic(filePath, payload) {
-  ensureDirectory(path.dirname(filePath));
-  const tempPath = `${filePath}.tmp`;
-  fs.writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-  fs.renameSync(tempPath, filePath);
-}
+function sleepSync(milliseconds) {
+  const delayMs = Math.max(0, Math.floor(Number(milliseconds) || 0));
+  if (delayMs <= 0) return;
+  Atomics.wait(CHAT_ATOMIC_RENAME_SLEEP_CELL, 0, 0, delayMs);
+}
+
+function writeJsonAtomic(filePath, payload, {
+  renameSyncImpl = fs.renameSync,
+  sleepSyncImpl = sleepSync,
+  randomUUIDImpl = randomUUID
+} = {}) {
+  ensureDirectory(path.dirname(filePath));
+  const tempPath = `${filePath}.${process.pid}.${randomUUIDImpl()}.tmp`;
+  let renameAttempts = 0;
+  const retryDelays = [];
+  try {
+    fs.writeFileSync(tempPath, `${JSON.stringify(payload, null, 2)}\n`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o600
+    });
+    while (true) {
+      renameAttempts += 1;
+      try {
+        renameSyncImpl(tempPath, filePath);
+        return;
+      } catch (error) {
+        const retryDelayMs = CHAT_ATOMIC_RENAME_RETRY_DELAYS_MS[renameAttempts - 1];
+        if (
+          !CHAT_ATOMIC_RENAME_RETRY_CODES.has(error?.code)
+          || retryDelayMs === undefined
+        ) {
+          try {
+            error.atomic_rename_attempts = renameAttempts;
+            error.atomic_rename_retry_delays_ms = [...retryDelays];
+            error.atomic_rename_source = tempPath;
+            error.atomic_rename_target = filePath;
+          } catch {
+            // Preserve the original filesystem error when it is not extensible.
+          }
+          throw error;
+        }
+        retryDelays.push(retryDelayMs);
+        sleepSyncImpl(retryDelayMs);
+      }
+    }
+  } finally {
+    try {
+      if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+    } catch {
+      // Best-effort cleanup only; never hide the original persistence outcome.
+    }
+  }
+}
 
 function readJsonFile(filePath) {
   try {
@@ -218,9 +274,10 @@ function selectedChatJobForCsv(meta = {}, snapshot = {}) {
   };
 }
 
-function buildChatCsvInputRows(snapshot = {}, meta = {}) {
-  const normalized = meta.normalized || {};
-  const context = snapshot.context || {};
+function buildChatCsvInputRows(snapshot = {}, meta = {}) {
+  const normalized = meta.normalized || {};
+  const context = snapshot.context || {};
+  const processingFloor = snapshot.summary?.collect_cv_processing_floor || {};
   const postAction = shouldRequestChatResume(meta.args, context)
     ? "request_cv"
     : normalizeText(meta.args?.post_action || meta.args?.action || "") || "none";
@@ -243,12 +300,18 @@ function buildChatCsvInputRows(snapshot = {}, meta = {}) {
       max_greet_count: meta.args?.max_greet_count ?? ""
     },
     followUp: meta.args?.follow_up || null,
-    extraRows: [
-      ["chat_params.greeting_text", normalized.greetingText || meta.args?.greeting_text || meta.args?.greetingText || context.greeting_text || DEFAULT_CHAT_GREETING_TEXT],
-      ["chat_params.profile", normalized.profile || meta.args?.profile || context.profile || "default"]
-    ]
-  });
-}
+    extraRows: [
+      ["chat_params.greeting_text", normalized.greetingText || meta.args?.greeting_text || meta.args?.greetingText || context.greeting_text || DEFAULT_CHAT_GREETING_TEXT],
+      ["chat_params.profile", normalized.profile || meta.args?.profile || context.profile || "default"],
+      ["chat_params.collect_cv_processing_floor_enabled", context.collect_cv_processing_floor_enabled === true],
+      ["chat_params.collect_cv_processing_floor_min_ms", context.collect_cv_processing_floor_min_ms ?? ""],
+      ["chat_params.collect_cv_processing_floor_max_ms", context.collect_cv_processing_floor_max_ms ?? ""],
+      ["chat_params.collect_cv_processing_floor_count", processingFloor.count ?? snapshot.progress?.collect_cv_processing_floor_count ?? 0],
+      ["chat_params.collect_cv_processing_floor_delay_requested_ms", processingFloor.total_delay_requested_ms ?? snapshot.progress?.collect_cv_processing_floor_delay_requested_ms ?? 0],
+      ["chat_params.collect_cv_processing_floor_delay_ms", processingFloor.total_delay_elapsed_ms ?? snapshot.progress?.collect_cv_processing_floor_delay_ms ?? 0]
+    ]
+  });
+}
 
 function writeChatLegacyCsvAtomic(filePath, rows = [], snapshot = {}, meta = {}) {
   writeLegacyScreenCsv(filePath, {
@@ -257,11 +320,37 @@ function writeChatLegacyCsvAtomic(filePath, rows = [], snapshot = {}, meta = {})
   });
 }
 
-function readChatRunState(runId) {
-  const artifacts = getChatRunArtifacts(runId);
-  if (!artifacts) return null;
-  return readJsonFile(artifacts.run_state_path);
-}
+function readChatRunState(runId) {
+  const artifacts = getChatRunArtifacts(runId);
+  if (!artifacts) return null;
+  return readJsonFile(artifacts.run_state_path);
+}
+
+function hasChatCheckpointPayload(value) {
+  return Boolean(
+    value
+    && typeof value === "object"
+    && !Array.isArray(value)
+    && Object.keys(value).length > 0
+  );
+}
+
+function readHydratedChatCheckpoint(persisted = {}) {
+  const runId = normalizeRunId(persisted.run_id || persisted.runId);
+  const artifacts = getChatRunArtifacts(runId);
+  const checkpointPaths = [
+    persisted.resume?.checkpoint_path,
+    persisted.artifacts?.checkpoint_path,
+    artifacts?.checkpoint_path
+  ].map((value) => normalizeText(value)).filter(Boolean);
+  for (const checkpointPath of new Set(checkpointPaths)) {
+    const checkpoint = readJsonFile(checkpointPath);
+    if (checkpoint) return checkpoint;
+  }
+  return persisted.checkpoint && typeof persisted.checkpoint === "object"
+    ? persisted.checkpoint
+    : {};
+}
 
 function writeChatRunState(runId, payload) {
   const artifacts = getChatRunArtifacts(runId);
@@ -281,10 +370,13 @@ function buildInitialChatDetachedState(runId, {
   pid = process.pid
 } = {}) {
   const artifacts = getChatRunArtifacts(runId);
-  const now = new Date().toISOString();
-  const isAllTarget = normalized.publicTargetCount === "all";
-  const processedLimit = isAllTarget ? CHAT_ALL_MAX_CANDIDATES : Math.max(1, Number(normalized.targetCount) || 1);
-  return {
+  const now = new Date().toISOString();
+  const isAllTarget = normalized.publicTargetCount === "all";
+  const processedLimit = isAllTarget ? CHAT_ALL_MAX_CANDIDATES : Math.max(1, Number(normalized.targetCount) || 1);
+  const criteria = normalizeText(normalized.criteria || args.criteria || "");
+  const screeningMode = normalizeScreeningModeArg(args, { ...normalized, criteria });
+  const collectCvProcessingFloorEnabled = screeningMode === "collect_cv";
+  return {
     run_id: runId,
     mode: RUN_MODE_ASYNC,
     state: "queued",
@@ -306,9 +398,16 @@ function buildInitialChatDetachedState(runId, {
       passed: 0,
       skipped: 0,
       requested: 0,
-      request_satisfied: 0,
-      request_skipped: 0,
-      greet_count: 0
+      request_satisfied: 0,
+      request_skipped: 0,
+      greet_count: 0,
+      collect_cv_processing_floor_enabled: collectCvProcessingFloorEnabled,
+      collect_cv_processing_floor_min_ms: collectCvProcessingFloorEnabled ? CHAT_COLLECT_CV_PROCESSING_FLOOR_MIN_MS : null,
+      collect_cv_processing_floor_max_ms: collectCvProcessingFloorEnabled ? CHAT_COLLECT_CV_PROCESSING_FLOOR_MAX_MS : null,
+      collect_cv_processing_floor_count: 0,
+      collect_cv_processing_floor_delay_requested_ms: 0,
+      collect_cv_processing_floor_delay_ms: 0,
+      collect_cv_processing_floor_current: null
     },
     last_message: "Boss chat detached worker is queued.",
     context: {
@@ -318,7 +417,13 @@ function buildInitialChatDetachedState(runId, {
       profile: normalized.profile || args.profile || "default",
       job: normalized.job || args.job || "",
       start_from: normalized.startFrom || args.start_from || "",
-      criteria: normalized.criteria || args.criteria || "",
+      criteria,
+      criteria_present: Boolean(criteria),
+      screening_mode: screeningMode,
+      cv_collection_mode: collectCvProcessingFloorEnabled,
+      collect_cv_processing_floor_enabled: collectCvProcessingFloorEnabled,
+      collect_cv_processing_floor_min_ms: collectCvProcessingFloorEnabled ? CHAT_COLLECT_CV_PROCESSING_FLOOR_MIN_MS : null,
+      collect_cv_processing_floor_max_ms: collectCvProcessingFloorEnabled ? CHAT_COLLECT_CV_PROCESSING_FLOOR_MAX_MS : null,
       greeting_text: normalized.greetingText || args.greeting_text || args.greetingText || DEFAULT_CHAT_GREETING_TEXT,
       target_count: normalized.publicTargetCount ?? normalized.targetCount ?? null,
       target_count_semantics: TARGET_COUNT_SEMANTICS,
@@ -385,33 +490,42 @@ function patchPersistedChatControl(runId, controlPatch = {}, {
   };
 }
 
-function launchDetachedChatWorker(runId) {
-  const artifacts = getChatRunArtifacts(runId);
-  if (!artifacts) throw new Error("Invalid chat run_id");
-  fs.mkdirSync(path.dirname(artifacts.worker_stdout_path), { recursive: true });
-  const stdoutFd = fs.openSync(artifacts.worker_stdout_path, "a");
-  const stderrFd = fs.openSync(artifacts.worker_stderr_path, "a");
-  let child;
-  try {
-    child = spawn(process.execPath, [
-      DETACHED_WORKER_SCRIPT,
-      "--domain",
-      "chat",
-      "--run-id",
-      runId
-    ], {
-      detached: true,
-      stdio: ["ignore", stdoutFd, stderrFd],
-      windowsHide: true,
-      env: process.env
-    });
-  } finally {
-    fs.closeSync(stdoutFd);
-    fs.closeSync(stderrFd);
-  }
-  if (typeof child?.unref === "function") child.unref();
-  return child;
-}
+function launchDetachedChatWorker(runId, { screenConfigPath = "" } = {}) {
+  const artifacts = getChatRunArtifacts(runId);
+  if (!artifacts) throw new Error("Invalid chat run_id");
+  const child = chatDetachedWorkerLauncherImpl({
+    nodePath: process.execPath,
+    workerScriptPath: DETACHED_WORKER_SCRIPT,
+    domain: "chat",
+    runId,
+    stdoutPath: artifacts.worker_stdout_path,
+    stderrPath: artifacts.worker_stderr_path,
+    chatRuntimeHomePath: getBossChatDataDir(),
+    screenConfigPath,
+    environment: process.env
+  });
+  if (typeof child?.once === "function") {
+    child.once("error", (error) => {
+      markBossChatDetachedWorkerFailed(runId, error, {
+        code: "CHAT_WORKER_PROCESS_ERROR",
+        message: "Boss chat detached worker process emitted an asynchronous error."
+      });
+    });
+    child.once("exit", (exitCode, signal) => {
+      const normalizedSignal = normalizeText(signal);
+      const exitLabel = Number.isInteger(exitCode) ? `code=${exitCode}` : "code=unknown";
+      const signalLabel = normalizedSignal ? `, signal=${normalizedSignal}` : "";
+      const error = new Error(`Boss chat detached worker exited before writing a terminal state (${exitLabel}${signalLabel}).`);
+      markBossChatDetachedWorkerFailed(runId, error, {
+        code: "CHAT_WORKER_EXITED_EARLY",
+        workerExitCode: Number.isInteger(exitCode) ? exitCode : null,
+        workerSignal: normalizedSignal || null
+      });
+    });
+  }
+  if (typeof child?.unref === "function") child.unref();
+  return child;
+}
 
 function toIsoOrNull(value) {
   const normalized = normalizeText(value);
@@ -500,16 +614,22 @@ function getChatRunMeta(runId) {
   return chatRunMeta.get(runId) || {};
 }
 
-function ensureChatRunArtifacts(snapshot) {
+function ensureChatRunArtifacts(snapshot) {
   const artifacts = getChatRunArtifacts(snapshot?.runId || snapshot?.run_id);
   if (!artifacts) return null;
 
   const meta = getChatRunMeta(snapshot?.runId || snapshot?.run_id);
-  const checkpoint = snapshot?.checkpoint && typeof snapshot.checkpoint === "object"
-    ? snapshot.checkpoint
-    : {};
-  writeJsonAtomic(artifacts.checkpoint_path, checkpoint);
-  if (meta) meta.checkpointPath = artifacts.checkpoint_path;
+  const snapshotCheckpoint = snapshot?.checkpoint && typeof snapshot.checkpoint === "object"
+    ? snapshot.checkpoint
+    : {};
+  const existingCheckpoint = readJsonFile(artifacts.checkpoint_path);
+  const checkpoint = hasChatCheckpointPayload(snapshotCheckpoint)
+    ? snapshotCheckpoint
+    : existingCheckpoint || snapshotCheckpoint;
+  if (hasChatCheckpointPayload(snapshotCheckpoint) || !existingCheckpoint) {
+    writeJsonAtomic(artifacts.checkpoint_path, checkpoint);
+  }
+  if (meta) meta.checkpointPath = artifacts.checkpoint_path;
 
   const summary = snapshot?.summary && typeof snapshot.summary === "object" ? snapshot.summary : null;
   const checkpointResults = Array.isArray(checkpoint.results) ? checkpoint.results : [];
@@ -547,16 +667,21 @@ function ensureChatRunArtifacts(snapshot) {
   return artifacts;
 }
 
-function persistChatCheckpointSnapshot(normalized) {
-  const artifacts = getChatRunArtifacts(normalized?.run_id || normalized?.runId);
-  if (!artifacts) return;
-  const checkpoint = normalized?.checkpoint && typeof normalized.checkpoint === "object"
-    ? normalized.checkpoint
-    : {};
-  writeJsonAtomic(artifacts.checkpoint_path, checkpoint);
-  const meta = getChatRunMeta(normalized?.run_id || normalized?.runId);
-  if (meta) meta.checkpointPath = artifacts.checkpoint_path;
-}
+function persistChatCheckpointSnapshot(normalized) {
+  const artifacts = getChatRunArtifacts(normalized?.run_id || normalized?.runId);
+  if (!artifacts) return;
+  const meta = getChatRunMeta(normalized?.run_id || normalized?.runId);
+  const checkpoint = normalized?.checkpoint && typeof normalized.checkpoint === "object"
+    ? normalized.checkpoint
+    : {};
+  const existingCheckpoint = readJsonFile(artifacts.checkpoint_path);
+  if (!hasChatCheckpointPayload(checkpoint) && existingCheckpoint) {
+    if (meta) meta.checkpointPath = artifacts.checkpoint_path;
+    return;
+  }
+  writeJsonAtomic(artifacts.checkpoint_path, checkpoint);
+  if (meta) meta.checkpointPath = artifacts.checkpoint_path;
+}
 
 function isPidAlive(pid) {
   const numericPid = Number(pid);
@@ -570,15 +695,15 @@ function isPidAlive(pid) {
   }
 }
 
-function snapshotFromPersistedChatRun(persisted = {}) {
-  return {
+function snapshotFromPersistedChatRun(persisted = {}) {
+  return {
     runId: persisted.run_id || persisted.runId,
     name: persisted.name || persisted.run_id || persisted.runId,
     status: persisted.status || persisted.state,
     phase: persisted.stage || persisted.phase,
     progress: persisted.progress || {},
     context: persisted.context || {},
-    checkpoint: persisted.checkpoint || {},
+    checkpoint: readHydratedChatCheckpoint(persisted),
     startedAt: persisted.started_at || persisted.startedAt,
     updatedAt: persisted.updated_at || persisted.updatedAt,
     completedAt: persisted.completed_at || persisted.completedAt || null,
@@ -613,7 +738,7 @@ function attachLegacyArtifactsToPersistedChatRun(persisted = {}) {
   return persistDiskChatRun(runId, next);
 }
 
-function finalizePersistedChatRun(persisted = {}, {
+function finalizePersistedChatRun(persisted = {}, {
   status = RUN_STATUS_FAILED,
   error = null,
   message = ""
@@ -621,30 +746,51 @@ function finalizePersistedChatRun(persisted = {}, {
   const runId = normalizeRunId(persisted.run_id || persisted.runId);
   if (!runId) return persisted;
   const now = new Date().toISOString();
-  const normalizedError = status === RUN_STATUS_FAILED
-    ? {
-        name: error?.name || "Error",
-        code: error?.code || "STALE_RUN_PROCESS_EXITED",
-        message: error?.message || message || "Boss chat run process exited before it wrote a terminal state."
-      }
-    : null;
-  const next = {
+  const normalizedError = status === RUN_STATUS_FAILED
+    ? {
+        name: error?.name || "Error",
+        code: error?.code || "STALE_RUN_PROCESS_EXITED",
+        message: error?.message || message || "Boss chat run process exited before it wrote a terminal state."
+      }
+    : null;
+  if (normalizedError) {
+    for (const field of ["worker_error_code", "worker_exit_code", "worker_signal"]) {
+      if (error?.[field] !== undefined && error?.[field] !== null && error?.[field] !== "") {
+        normalizedError[field] = error[field];
+      }
+    }
+    if (normalizeText(error?.stack || "")) {
+      normalizedError.stack = String(error.stack).slice(0, 8000);
+    }
+  }
+  const workerLastHeartbeatAt = normalizeText(
+    persisted.recovery?.worker_last_heartbeat_at
+    || persisted.heartbeat_at
+    || ""
+  ) || null;
+  const next = {
     ...persisted,
     run_id: runId,
     state: status,
     status,
-    stage: persisted.stage || persisted.phase || "chat:stale",
-    updated_at: now,
-    heartbeat_at: now,
-    completed_at: persisted.completed_at || now,
+    stage: persisted.stage || persisted.phase || "chat:stale",
+    updated_at: now,
+    heartbeat_at: persisted.heartbeat_at || now,
+    completed_at: persisted.completed_at || now,
     last_message: normalizedError?.message || message || status,
     control: {
       ...(persisted.control || {}),
       cancel_requested: false
     },
-    error: normalizedError,
-    summary: persisted.summary || null
-  };
+    error: normalizedError,
+    summary: persisted.summary || null,
+    recovery: {
+      ...(persisted.recovery && typeof persisted.recovery === "object" ? persisted.recovery : {}),
+      worker_last_heartbeat_at: workerLastHeartbeatAt,
+      reconciled_at: now,
+      reconciliation_reason: normalizedError?.code || status
+    }
+  };
   return attachLegacyArtifactsToPersistedChatRun(next);
 }
 
@@ -654,11 +800,21 @@ export function markBossChatDetachedWorkerFailed(runId, error, options = {}) {
   const persisted = readChatRunState(normalizedRunId) || buildInitialChatDetachedState(normalizedRunId, {});
   const state = normalizeText(persisted.state || persisted.status);
   if (TERMINAL_STATUSES.has(state)) return persisted;
-  const errorPayload = {
+  const errorPayload = {
     name: error?.name || "Error",
     code: options.code || error?.code || "CHAT_WORKER_UNHANDLED_EXCEPTION",
-    message: normalizeText(error?.message || error || options.message) || "Boss chat detached worker exited unexpectedly."
-  };
+    message: normalizeText(error?.message || error || options.message) || "Boss chat detached worker exited unexpectedly."
+  };
+  const workerErrorCode = normalizeText(error?.code || "");
+  if (workerErrorCode && workerErrorCode !== errorPayload.code) {
+    errorPayload.worker_error_code = workerErrorCode;
+  }
+  if (Number.isInteger(options.workerExitCode)) {
+    errorPayload.worker_exit_code = options.workerExitCode;
+  }
+  if (normalizeText(options.workerSignal || "")) {
+    errorPayload.worker_signal = normalizeText(options.workerSignal);
+  }
   if (normalizeText(error?.stack || "")) {
     errorPayload.stack = String(error.stack).slice(0, 8000);
   }
@@ -1346,9 +1502,10 @@ function getRunOptions(args, normalized, session, { workspaceRoot = "", configRe
     listSettleMs: parsePositiveInteger(args.list_settle_ms, slowLive ? 1800 : 1200),
     listFallbackPoint: null,
     imageOutputDir: resolveBossConfiguredOutputDir("", getChatRunsDir()),
-    humanRestEnabled: humanBehavior.restEnabled,
-    humanBehavior,
-    name: "mcp-boss-chat-run"
+    humanRestEnabled: humanBehavior.restEnabled,
+    humanBehavior,
+    actionJournalScope: `boss-chat-cdp:${normalized.host}:${normalized.port}`,
+    name: "mcp-boss-chat-run"
   };
 }
 
@@ -1816,7 +1973,9 @@ export async function startBossChatDetachedRunTool({ workspaceRoot = "", args =
 
   let child;
   try {
-    child = launchDetachedChatWorker(runId);
+    child = launchDetachedChatWorker(runId, {
+      screenConfigPath: defaultConfigResolution?.config_path || ""
+    });
     const now = new Date().toISOString();
     const latest = readChatRunState(runId) || initial;
     const latestState = normalizeText(latest.state || latest.status);
@@ -2181,24 +2340,38 @@ export function cancelBossChatRunTool({ args = {} } = {}) {
   }
 }
 
-export function __setChatMcpConnectorForTests(nextConnector) {
-  chatConnectorImpl = typeof nextConnector === "function" ? nextConnector : connectChatChromeSession;
-}
-
-export function __setChatMcpJobReaderForTests(nextReader) {
+export function __setChatMcpConnectorForTests(nextConnector) {
+  chatConnectorImpl = typeof nextConnector === "function" ? nextConnector : connectChatChromeSession;
+}
+
+export function __writeChatJsonAtomicForTests(filePath, payload, options = {}) {
+  return writeJsonAtomic(filePath, payload, options);
+}
+
+export function __setChatMcpJobReaderForTests(nextReader) {
   chatJobReaderImpl = typeof nextReader === "function" ? nextReader : readChatJobOptionsFromSession;
 }
 
-export function __setChatMcpWorkflowForTests(nextWorkflow) {
+export function __setChatMcpWorkflowForTests(nextWorkflow) {
   chatWorkflowImpl = typeof nextWorkflow === "function" ? nextWorkflow : runChatWorkflow;
   chatRunService = createChatRunService({
     idPrefix: "mcp_chat",
     workflow: (...args) => chatWorkflowImpl(...args),
     onSnapshot: persistChatLifecycleSnapshot
   });
-}
-
-export function __resetChatMcpStateForTests() {
+}
+
+export function __setChatMcpSpawnForTests(nextSpawn) {
+  chatDetachedWorkerLauncherImpl = typeof nextSpawn === "function"
+    ? (options) => launchDetachedWorker({
+        ...options,
+        platform: "test-posix",
+        spawnImpl: nextSpawn
+      })
+    : launchDetachedWorker;
+}
+
+export function __resetChatMcpStateForTests() {
   for (const meta of chatRunMeta.values()) {
     try {
       meta.session?.close?.();
@@ -2207,7 +2380,8 @@ export function __resetChatMcpStateForTests() {
     }
   }
   chatRunMeta.clear();
-  __setChatMcpConnectorForTests(null);
-  __setChatMcpJobReaderForTests(null);
-  __setChatMcpWorkflowForTests(null);
-}
+  __setChatMcpConnectorForTests(null);
+  __setChatMcpJobReaderForTests(null);
+  __setChatMcpWorkflowForTests(null);
+  __setChatMcpSpawnForTests(null);
+}

package/src/chat-runtime-config.js

@@ -277,11 +277,13 @@ export function resolveHumanBehaviorForRun(args = {}, config = {}) {
     override.enabled = rawBehavior;
   } else if (typeof rawBehavior === "string") {
     applyHumanBehaviorProfileDefaults(override, rawBehavior);
-  } else if (rawBehavior && typeof rawBehavior === "object" && !Array.isArray(rawBehavior)) {
-    const rawProfile = readFirstOwn(rawBehavior, ["profile", "mode", "behaviorProfile", "behavior_profile"]);
-    if (rawProfile !== undefined) applyHumanBehaviorProfileDefaults(override, rawProfile);
-    Object.assign(override, rawBehavior);
-  }
+  } else if (rawBehavior && typeof rawBehavior === "object" && !Array.isArray(rawBehavior)) {
+    const rawProfile = readFirstOwn(rawBehavior, ["profile", "mode", "behaviorProfile", "behavior_profile"]);
+    if (rawProfile !== undefined) applyHumanBehaviorProfileDefaults(override, rawProfile);
+    Object.assign(override, rawBehavior);
+    const rawRestLevel = readFirstOwn(rawBehavior, ["restLevel", "rest_level"]);
+    if (rawRestLevel !== undefined) override.restLevel = rawRestLevel;
+  }
 
   const profile = readFirstOwn(args, ["human_behavior_profile", "humanBehaviorProfile"]);
   if (profile !== undefined) applyHumanBehaviorProfileDefaults(override, profile);