@reconcrap/boss-recommend-mcp 2.0.2 → 2.0.4

package/README.md

@@ -221,10 +221,10 @@ config/screening-config.example.json
 
 - `openaiOrganization`
 - `openaiProject`
-- `debugPort`
-- `outputDir`
+- `debugPort`：未显式传 `port` 时，recommend / search / chat CDP-only MCP run 和健康检查默认连接这个 Chrome 调试端口。
+- `outputDir`：recommend / search / chat 完成后的最终 CSV 与 report JSON 会写入这里；run state / checkpoint 仍保留在各自状态目录，方便 pause/resume/cancel。
 - `llmThinkingLevel`：默认 `low`。可设为 `off/minimal/low/medium/high/auto/current`，用于控制 OpenAI-compatible LLM 的 thinking/reasoning 强度。
-- `humanRestEnabled`：默认 `false`。`false` 时 recommend-screen 随机休息/批次休息与 boss-chat 批次休息均为 `0ms`；`true` 时恢复随机休息节奏。
+- `humanRestEnabled`：默认 `false`。当前 CDP-only recommend / search / chat run 尚未实现随机休息层，因此会读取并保留该字段但不改变节奏；如后续重新加入 human rest，应以此字段为默认值。
 
 ## 常用命令
 

package/config/screening-config.example.json

@@ -1,11 +1,13 @@
 {
   "baseUrl": "https://api.openai.com/v1",
   "apiKey": "replace-with-openai-api-key",
-  "model": "gpt-4.1-mini",
-  "llmThinkingLevel": "low",
-  "llmTimeoutMs": 60000,
-  "llmMaxRetries": 3,
-  "humanRestEnabled": false,
-  "openaiOrganization": "optional-org-id",
-  "openaiProject": "optional-project-id"
-}
+  "model": "gpt-4.1-mini",
+  "llmThinkingLevel": "low",
+  "llmTimeoutMs": 60000,
+  "llmMaxRetries": 3,
+  "debugPort": 9222,
+  "outputDir": "",
+  "humanRestEnabled": false,
+  "openaiOrganization": "optional-org-id",
+  "openaiProject": "optional-project-id"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reconcrap/boss-recommend-mcp",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Unified MCP pipeline for recommend-page filtering and screening on Boss Zhipin",
   "keywords": [
     "boss",

package/skills/boss-chat/SKILL.md

@@ -57,6 +57,9 @@ description: "Use when users want Boss chat-page screening/outreach via the bund
   - 只在用户明确是 chat-only 任务时使用本 skill。
   - 只要用户提到推荐页、先找人后沟通、或需要推荐筛选阶段，禁止直接调用 `start_boss_chat_run`；必须先交给 `boss-recommend-pipeline` 完成推荐页任务。
   - 不得在 recommend 任务尚未完成时并行启动独立 chat run。
+- 启动或准备 chat run 时，若本机默认 `127.0.0.1:9222` Chrome DevTools 端口不可连，工具会自动打开 Chrome 并导航到 `https://www.zhipin.com/web/chat/index`。
+- 只有工具返回 `BOSS_LOGIN_REQUIRED` / `requires_login=true` 时，才要求用户在自动打开的 Chrome 窗口人工登录 Boss 后重试；不要把“没开 9222 Chrome”当作缺参。
+- 若本机找不到 Chrome，可提示用户设置 `BOSS_MCP_CHROME_PATH` 或 `BOSS_RECOMMEND_CHROME_PATH`；非本机 debug host 不自动启动。
 - `job` / `start_from` / `criteria` 缺一不可；缺参时只补缺口。
 - `target_count` 在 chat-only 启动前也是必填项，不能默认省略。
 - 当用户说“全部候选人/所有候选人”时，必须按“扫到底（unlimited）”处理，不要再追问正整数。

package/skills/boss-recommend-pipeline/SKILL.md

@@ -118,8 +118,14 @@ description: "Use when users want Boss recommend-page filtering/screening via bo
 
 - 执行前必须通过：
   - `screening-config.json` 可用且非占位值（`baseUrl/apiKey/model`）
-  - Chrome DevTools 端口可连
-  - Boss 已登录且位于 `https://www.zhipin.com/web/chat/recommend`
+  - 工具可连接或自动启动本机 Chrome DevTools 端口（默认 `127.0.0.1:9222`）
+  - Boss 已登录；若当前没有 9222 Chrome，工具会自动打开 Chrome 并导航到 `https://www.zhipin.com/web/chat/recommend`
+  - 只有工具返回 `BOSS_LOGIN_REQUIRED` / `requires_login=true` 时，才要求用户人工登录 Boss 后重试
+
+- 不要在运行前要求用户手动打开 9222 Chrome。只有这些情况需要人工介入：
+  - 工具明确报告 `BOSS_LOGIN_REQUIRED`
+  - 本机找不到 Chrome 可执行文件，并提示设置 `BOSS_MCP_CHROME_PATH` 或 `BOSS_RECOMMEND_CHROME_PATH`
+  - 用户配置的是非本机 debug host，工具无法安全自动启动
 
 - `PIPELINE_PREFLIGHT_FAILED` 处理顺序：
   1. 若 `screen_config` 失败：让用户提供真实 `baseUrl/apiKey/model`，并在 `guidance.config_path` 修改后明确回复“已修改完成”。
@@ -153,3 +159,4 @@ MCP 不可用时：
 - 页面就绪失败提示必须包含 `debug_port`、recommend URL、以及登录 URL（若未登录）：
   - `https://www.zhipin.com/web/chat/recommend`
   - `https://www.zhipin.com/web/user/?ka=bticket`
+- 若错误是 `BOSS_LOGIN_REQUIRED`，提示用户在自动打开的 Chrome 窗口完成登录，然后原参数重试；不要改用 search/recruit 路径。

package/skills/boss-recruit-pipeline/SKILL.md

@@ -25,6 +25,9 @@ description: "Use when users want Boss search/recruit-page screening via the uni
 - 如果用户说聊天页、未读、全部聊天、求简历，必须交给 `boss-chat`。
 - 禁止调用旧包：`@reconcrap/boss-recruit-mcp`、`boss-recruit-mcp`、旧本地 recruit repo、旧 vendor 脚本。
 - 浏览器自动化必须走 CDP-only 2.x MCP 工具；不得要求用户启用 legacy page-JS 或 `Runtime.evaluate` 路径。
+- 启动 search/recruit run 时，若本机默认 `127.0.0.1:9222` Chrome DevTools 端口不可连，工具会自动打开 Chrome 并导航到 `https://www.zhipin.com/web/chat/search`。
+- 只有工具返回 `BOSS_LOGIN_REQUIRED` / `requires_login=true` 时，才要求用户在自动打开的 Chrome 窗口人工登录 Boss 后重试；不要把“没开 9222 Chrome”当作缺参。
+- 若本机找不到 Chrome，可提示用户设置 `BOSS_MCP_CHROME_PATH` 或 `BOSS_RECOMMEND_CHROME_PATH`；非本机 debug host 不自动启动。
 - 若用户未提供岗位，必须先询问岗位。搜索页岗位选择在关键词输入框旁边；不要猜测默认岗位。
 - 若用户提供城市、学历、学校、关键词、过滤已看、人选目标数、筛选条件、post action、max greet 等参数，必须逐项传入或确认。
 - `post_action=greet` 时必须确认 `max_greet_count`；不要默认等于 `target_count`。

package/src/chat-mcp.js

@@ -4,8 +4,13 @@ import process from "node:process";
 import {
   assertNoForbiddenCdpCalls,
   bringPageToFront,
-  connectToChromeTarget,
+  connectToChromeTargetOrOpen,
+  createBossLoginRequiredError,
+  detectBossLoginState,
   enableDomains,
+  getMainFrameUrl,
+  isBossLoginUrl,
+  waitForMainFrameUrl,
   sleep
 } from "./core/browser/index.js";
 import {
@@ -40,6 +45,7 @@ import {
   getBossChatDataDir,
   getBossChatTargetCountValue,
   normalizeTargetCountInput,
+  resolveBossConfiguredOutputDir,
   resolveBossChatRuntimeLayout,
   resolveBossScreeningConfig
 } from "./chat-runtime-config.js";
@@ -118,12 +124,14 @@ function getChatRunArtifacts(runId) {
   const normalized = normalizeRunId(runId);
   if (!normalized) return null;
   const runsDir = getChatRunsDir();
+  const outputDir = resolveBossConfiguredOutputDir("", runsDir);
   return {
     runs_dir: runsDir,
+    output_dir: outputDir,
     run_state_path: path.join(runsDir, `${normalized}.json`),
     checkpoint_path: path.join(runsDir, `${normalized}.checkpoint.json`),
-    output_csv: path.join(runsDir, `${normalized}.results.csv`),
-    report_json: path.join(runsDir, `${normalized}.report.json`)
+    output_csv: path.join(outputDir, `${normalized}.results.csv`),
+    report_json: path.join(outputDir, `${normalized}.report.json`)
   };
 }
 
@@ -472,6 +480,14 @@ async function waitForHealthyChat(client, config, {
   const started = Date.now();
   let lastCheck = null;
   while (Date.now() - started <= timeoutMs) {
+    const loginDetection = await detectBossLoginState(client).catch(() => null);
+    if (loginDetection?.requires_login) {
+      return {
+        status: "login_required",
+        summary: "Boss login is required",
+        loginDetection
+      };
+    }
     const roots = await resolveChatSelfHealRoots(client, config);
     lastCheck = await runSelfHealCheck({
       client,
@@ -493,24 +509,18 @@ async function connectChatChromeSession({
   allowNavigate = true,
   slowLive = false
 } = {}) {
-  let session;
-  try {
-    session = await connectToChromeTarget({
-      host,
-      port,
-      targetUrlIncludes
-    });
-  } catch (error) {
-    if (!allowNavigate) throw error;
-    session = await connectToChromeTarget({
-      host,
-      port,
-      targetPredicate: (target) => (
-        target?.type === "page"
-        && isRecoverableChatTargetUrl(target?.url)
-      )
-    });
-  }
+  const session = await connectToChromeTargetOrOpen({
+    host,
+    port,
+    targetUrlIncludes,
+    targetUrl: CHAT_TARGET_URL,
+    allowNavigate,
+    slowLive,
+    fallbackTargetPredicate: (target) => (
+      target?.type === "page"
+      && (isRecoverableChatTargetUrl(target?.url) || String(target?.url || "").includes("zhipin.com"))
+    )
+  });
 
   const { client, target } = session;
   await enableDomains(client, ["Page", "DOM", "Input", "Network", "Accessibility"]);
@@ -527,20 +537,90 @@ async function connectChatChromeSession({
   if (allowNavigate && shouldNavigateToChat(targetUrl)) {
     await client.Page.navigate({ url: CHAT_TARGET_URL });
     const settleMs = slowLive ? 10000 : 5000;
-    await sleep(settleMs);
+    const waited = await waitForMainFrameUrl(
+      client,
+      (url) => isBossLoginUrl(url) || !shouldNavigateToChat(url),
+      { timeoutMs: settleMs, intervalMs: 500 }
+    );
     navigation = {
       navigated: true,
       url: CHAT_TARGET_URL,
-      settle_ms: settleMs
+      settle_ms: settleMs,
+      observed_url: waited.url || null,
+      observed_url_ok: waited.ok
     };
   }
+  let currentUrl = await getMainFrameUrl(client).catch(() => navigation.url || targetUrl);
+  if (allowNavigate && shouldNavigateToChat(currentUrl) && !isBossLoginUrl(currentUrl)) {
+    await client.Page.navigate({ url: CHAT_TARGET_URL });
+    const settleMs = slowLive ? 10000 : 5000;
+    const waited = await waitForMainFrameUrl(
+      client,
+      (url) => isBossLoginUrl(url) || !shouldNavigateToChat(url),
+      { timeoutMs: settleMs, intervalMs: 500 }
+    );
+    navigation = {
+      navigated: true,
+      url: CHAT_TARGET_URL,
+      settle_ms: settleMs,
+      observed_url: waited.url || null,
+      observed_url_ok: waited.ok,
+      reason: "observed_url_mismatch"
+    };
+    currentUrl = await getMainFrameUrl(client).catch(() => waited.url || currentUrl);
+  }
+  const loginDetection = await detectBossLoginState(client, { currentUrl }).catch(() => ({
+    requires_login: isBossLoginUrl(currentUrl),
+    reason: "login_detection_failed",
+    current_url: currentUrl
+  }));
+  if (loginDetection.requires_login) {
+    await session.close?.();
+    throw createBossLoginRequiredError({
+      domain: "chat",
+      currentUrl: loginDetection.current_url || currentUrl,
+      targetUrl: CHAT_TARGET_URL,
+      loginDetection,
+      chrome: session.chrome || null
+    });
+  }
+  if (shouldNavigateToChat(currentUrl)) {
+    await session.close?.();
+    throw new Error(`Boss chat page did not navigate to ${CHAT_TARGET_URL}; current URL: ${currentUrl || "unknown"}`);
+  }
 
   const selfHealConfig = buildChatSelfHealConfig();
   const health = await waitForHealthyChat(client, selfHealConfig, {
     timeoutMs: slowLive ? 180000 : 90000,
     intervalMs: slowLive ? 1200 : 800
   });
+  if (health?.loginDetection?.requires_login) {
+    await session.close?.();
+    throw createBossLoginRequiredError({
+      domain: "chat",
+      currentUrl: health.loginDetection.current_url || currentUrl,
+      targetUrl: CHAT_TARGET_URL,
+      loginDetection: health.loginDetection,
+      chrome: session.chrome || null
+    });
+  }
   if (!health || health.status !== HEALTH_STATUS.HEALTHY) {
+    const latestUrl = await getMainFrameUrl(client).catch(() => currentUrl);
+    const latestLoginDetection = await detectBossLoginState(client, { currentUrl: latestUrl }).catch(() => ({
+      requires_login: isBossLoginUrl(latestUrl),
+      reason: "login_detection_failed",
+      current_url: latestUrl
+    }));
+    if (latestLoginDetection.requires_login) {
+      await session.close?.();
+      throw createBossLoginRequiredError({
+        domain: "chat",
+        currentUrl: latestLoginDetection.current_url || latestUrl,
+        targetUrl: CHAT_TARGET_URL,
+        loginDetection: latestLoginDetection,
+        chrome: session.chrome || null
+      });
+    }
     throw new Error(`Boss chat page is not healthy: ${health?.status || "missing"}`);
   }
 
@@ -556,7 +636,7 @@ async function readChatJobOptionsFromSession(session) {
   return readChatJobOptions(session.client, roots.rootNodes.top);
 }
 
-function normalizeChatStartInput(args = {}) {
+function normalizeChatStartInput(args = {}, configResolution = null) {
   const target = normalizeTargetCountInput(getBossChatTargetCountValue(args));
   return {
     profile: normalizeText(args.profile) || "default",
@@ -568,7 +648,10 @@ function normalizeChatStartInput(args = {}) {
     targetCount: target.targetCount,
     publicTargetCount: target.publicValue,
     host: normalizeText(args.host) || DEFAULT_CHAT_HOST,
-    port: parsePositiveInteger(args.port, DEFAULT_CHAT_PORT),
+    port: parsePositiveInteger(
+      args.port,
+      configResolution?.ok ? configResolution.config.debugPort : DEFAULT_CHAT_PORT
+    ),
     targetUrlIncludes: normalizeText(args.target_url_includes) || CHAT_TARGET_URL,
     allowNavigate: args.allow_navigate !== false,
     slowLive: args.slow_live === true
@@ -723,7 +806,6 @@ function getRunOptions(args, normalized, session, { workspaceRoot = "" } = {}) {
   const shouldRequestResume = shouldRequestChatResume(args);
   const useLlm = shouldUseChatLlm(args, shouldRequestResume);
   const configResolution = useLlm ? resolveBossScreeningConfig(workspaceRoot) : { ok: false };
-  const configFile = configResolution.ok ? readJsonFile(configResolution.config_path) : null;
   return {
     client: session.client,
     targetUrl: CHAT_TARGET_URL,
@@ -750,8 +832,7 @@ function getRunOptions(args, normalized, session, { workspaceRoot = "" } = {}) {
     maxImagePages: parsePositiveInteger(args.max_image_pages, 8),
     imageWheelDeltaY: parsePositiveInteger(args.image_wheel_delta_y, 650),
     llmConfig: configResolution.ok ? {
-      ...configResolution.config,
-      apiKey: configFile?.apiKey || ""
+      ...configResolution.config
     } : null,
     llmTimeoutMs: parsePositiveInteger(args.llm_timeout_ms, slowLive ? 180000 : 120000),
     llmImageLimit: parsePositiveInteger(args.llm_image_limit, 8),
@@ -811,7 +892,8 @@ function trackChatRun(runId) {
 }
 
 async function startBossChatRunInternal(args = {}, { workspaceRoot = "" } = {}) {
-  const normalized = normalizeChatStartInput(args);
+  const defaultConfigResolution = resolveBossScreeningConfig(workspaceRoot);
+  const normalized = normalizeChatStartInput(args, defaultConfigResolution);
   const missingFields = getMissingChatStartFields(args, normalized);
   if (missingFields.length) {
     return buildNeedInputResponse({
@@ -845,13 +927,21 @@ async function startBossChatRunInternal(args = {}, { workspaceRoot = "" } = {})
       slowLive: normalized.slowLive
     });
   } catch (error) {
+    const loginRequired = error?.code === "BOSS_LOGIN_REQUIRED";
     return {
       status: "FAILED",
       error: {
-        code: "BOSS_CHAT_PAGE_NOT_READY",
+        code: loginRequired ? "BOSS_LOGIN_REQUIRED" : "BOSS_CHAT_PAGE_NOT_READY",
         message: error?.message || "Boss chat page is not ready",
+        requires_login: Boolean(error?.requires_login),
+        login_url: error?.login_url || null,
+        login_detection: error?.login_detection || null,
+        chrome: error?.chrome || null,
+        current_url: error?.current_url || null,
+        target_url: error?.target_url || CHAT_TARGET_URL,
         retryable: true
-      }
+      },
+      chrome: error?.chrome || null
     };
   }
 
@@ -880,7 +970,8 @@ async function startBossChatRunInternal(args = {}, { workspaceRoot = "" } = {})
       host: normalized.host,
       port: normalized.port,
       target_url: session.navigation?.url || session.target?.url || CHAT_TARGET_URL,
-      target_id: session.target?.id || null
+      target_id: session.target?.id || null,
+      auto_launch: session.chrome || null
     },
     health: session.health || null
   });
@@ -901,7 +992,8 @@ async function startBossChatRunInternal(args = {}, { workspaceRoot = "" } = {})
 }
 
 export async function prepareBossChatRunTool({ workspaceRoot = "", args = {} } = {}) {
-  const normalized = normalizeChatStartInput(args);
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
+  const normalized = normalizeChatStartInput(args, configResolution);
   let session;
   try {
     session = await chatConnectorImpl({
@@ -912,12 +1004,19 @@ export async function prepareBossChatRunTool({ workspaceRoot = "", args = {} } =
       slowLive: normalized.slowLive
     });
   } catch (error) {
+    const loginRequired = error?.code === "BOSS_LOGIN_REQUIRED";
     return {
       status: "FAILED",
       stage: "chat_run_setup",
       error: {
-        code: "BOSS_CHAT_PAGE_NOT_READY",
+        code: loginRequired ? "BOSS_LOGIN_REQUIRED" : "BOSS_CHAT_PAGE_NOT_READY",
         message: error?.message || "Boss chat page is not ready",
+        requires_login: Boolean(error?.requires_login),
+        login_url: error?.login_url || null,
+        login_detection: error?.login_detection || null,
+        chrome: error?.chrome || null,
+        current_url: error?.current_url || null,
+        target_url: error?.target_url || CHAT_TARGET_URL,
         retryable: true
       },
       runtime_evaluate_used: false,
@@ -926,7 +1025,8 @@ export async function prepareBossChatRunTool({ workspaceRoot = "", args = {} } =
       chrome: {
         host: normalized.host,
         port: normalized.port,
-        target_url: CHAT_TARGET_URL
+        target_url: CHAT_TARGET_URL,
+        auto_launch: error?.chrome || null
       }
     };
   }
@@ -979,16 +1079,24 @@ export async function prepareBossChatRunTool({ workspaceRoot = "", args = {} } =
         host: normalized.host,
         port: normalized.port,
         target_url: session.navigation?.url || session.target?.url || CHAT_TARGET_URL,
-        target_id: session.target?.id || null
+        target_id: session.target?.id || null,
+        auto_launch: session.chrome || null
       }
     };
   } catch (error) {
+    const loginRequired = error?.code === "BOSS_LOGIN_REQUIRED";
     return {
       status: "FAILED",
       stage: "chat_run_setup",
       error: {
-        code: "BOSS_CHAT_PREPARE_FAILED",
+        code: loginRequired ? "BOSS_LOGIN_REQUIRED" : "BOSS_CHAT_PREPARE_FAILED",
         message: error?.message || "Boss chat CDP-only prepare failed",
+        requires_login: Boolean(error?.requires_login),
+        login_url: error?.login_url || null,
+        login_detection: error?.login_detection || null,
+        chrome: error?.chrome || null,
+        current_url: error?.current_url || null,
+        target_url: error?.target_url || CHAT_TARGET_URL,
         retryable: true
       },
       runtime_evaluate_used: false,
@@ -998,7 +1106,8 @@ export async function prepareBossChatRunTool({ workspaceRoot = "", args = {} } =
         host: normalized.host,
         port: normalized.port,
         target_url: session.navigation?.url || session.target?.url || CHAT_TARGET_URL,
-        target_id: session.target?.id || null
+        target_id: session.target?.id || null,
+        auto_launch: session.chrome || null
       }
     };
   } finally {
@@ -1026,6 +1135,7 @@ export async function bossChatHealthCheckTool({ workspaceRoot = "", args = {} }
     cli_path: null,
     config_path: configResolution.config_path || null,
     config_dir: configResolution.config_dir || null,
+    output_dir: configResolution.ok ? configResolution.config.outputDir || null : null,
     debug_port: port,
     shared_llm_config: configResolution.ok === true,
     data_dir: runtimeLayout.data_dir,
@@ -1073,17 +1183,25 @@ export async function bossChatHealthCheckTool({ workspaceRoot = "", args = {} }
         host,
         port,
         target_url: session.navigation?.url || session.target?.url || CHAT_TARGET_URL,
-        target_id: session.target?.id || null
+        target_id: session.target?.id || null,
+        auto_launch: session.chrome || null
       },
       message: "Boss chat CDP-only health check passed with shared self-heal probes."
     };
   } catch (error) {
+    const loginRequired = error?.code === "BOSS_LOGIN_REQUIRED";
     return {
       status: "FAILED",
       ...basePayload,
       error: {
-        code: "BOSS_CHAT_PAGE_NOT_READY",
+        code: loginRequired ? "BOSS_LOGIN_REQUIRED" : "BOSS_CHAT_PAGE_NOT_READY",
         message: error?.message || "Boss chat page is not ready",
+        requires_login: Boolean(error?.requires_login),
+        login_url: error?.login_url || null,
+        login_detection: error?.login_detection || null,
+        chrome: error?.chrome || null,
+        current_url: error?.current_url || null,
+        target_url: error?.target_url || CHAT_TARGET_URL,
         retryable: true
       },
       runtime_evaluate_used: false,
@@ -1093,7 +1211,8 @@ export async function bossChatHealthCheckTool({ workspaceRoot = "", args = {} }
         host,
         port,
         target_url: session?.navigation?.url || session?.target?.url || targetUrlIncludes,
-        target_id: session?.target?.id || null
+        target_id: session?.target?.id || null,
+        auto_launch: error?.chrome || session?.chrome || null
       }
     };
   } finally {

package/src/chat-runtime-config.js

@@ -223,6 +223,22 @@ function parsePositiveInteger(raw, fallback = null) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 
+function parseConfigBoolean(raw, fallback = false) {
+  if (typeof raw === "boolean") return raw;
+  const normalized = normalizeText(raw).toLowerCase();
+  if (["true", "1", "yes", "y", "on", "enabled"].includes(normalized)) return true;
+  if (["false", "0", "no", "n", "off", "disabled"].includes(normalized)) return false;
+  return fallback;
+}
+
+function resolveConfigPathValue(raw, configDir) {
+  const normalized = normalizeText(raw);
+  if (!normalized) return "";
+  return path.isAbsolute(normalized)
+    ? path.resolve(normalized)
+    : path.resolve(configDir || process.cwd(), normalized);
+}
+
 function validateScreeningConfig(config) {
   if (!config || typeof config !== "object" || Array.isArray(config)) {
     return {
@@ -369,8 +385,12 @@ export function resolveBossScreeningConfig(workspaceRoot) {
     ok: true,
     config: {
       baseUrl: normalizeText(parsed.baseUrl).replace(/\/+$/, ""),
+      apiKey: normalizeText(parsed.apiKey),
       model: normalizeText(parsed.model),
-      debugPort: parsePositiveInteger(parsed.debugPort, 9222)
+      debugPort: parsePositiveInteger(parsed.debugPort, 9222),
+      llmThinkingLevel: normalizeText(parsed.llmThinkingLevel || parsed.thinkingLevel || parsed.reasoningEffort),
+      outputDir: resolveConfigPathValue(parsed.outputDir, configDir),
+      humanRestEnabled: parseConfigBoolean(parsed.humanRestEnabled, false)
     },
     config_path: configPath,
     config_dir: configDir,
@@ -378,6 +398,13 @@ export function resolveBossScreeningConfig(workspaceRoot) {
   };
 }
 
+export function resolveBossConfiguredOutputDir(workspaceRoot, fallbackDir = "") {
+  const configResolution = resolveBossScreeningConfig(workspaceRoot);
+  const configuredDir = configResolution.ok ? normalizeText(configResolution.config.outputDir) : "";
+  if (configuredDir) return configuredDir;
+  return fallbackDir ? path.resolve(fallbackDir) : "";
+}
+
 function isUnlimitedTargetCountToken(value) {
   const token = normalizeText(value).toLowerCase();
   if (!token) return false;