@reconcrap/boss-recommend-mcp 1.3.9 → 1.3.11

package/src/test-boss-chat.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { mkdir } from "node:fs/promises";
 
 import {
   cancelBossChatRun,
@@ -14,6 +15,8 @@ import {
 } from "./boss-chat.js";
 import { __testables as cliTestables } from "./cli.js";
 import { __testables as indexTestables } from "./index.js";
+import { BossChatApp } from "../vendor/boss-chat-cli/src/app.js";
+import { LlmClient, parseLlmJson } from "../vendor/boss-chat-cli/src/services/llm.js";
 
 const { handleRequest } = indexTestables;
 
@@ -273,6 +276,51 @@ async function testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli() {
     const stateAfterStartAll = readStubState(workspaceRoot);
     assert.equal(stateAfterStartAll.last_start_args.targetCount, "-1");
 
+    for (const target_count of ["all", -1, "-1", { value: "all" }, "all（扫到底）"]) {
+      const startedVariant = await startBossChatRun({
+        workspaceRoot,
+        input: {
+          profile: "default",
+          job: "算法工程师",
+          start_from: "all",
+          criteria: "全部候选人都过一遍",
+          target_count
+        }
+      });
+      assert.equal(startedVariant.status, "ACCEPTED");
+      assert.equal(readStubState(workspaceRoot).last_start_args.targetCount, "-1");
+    }
+
+    const startedCamelCase = await startBossChatRun({
+      workspaceRoot,
+      input: {
+        profile: "default",
+        job: "算法工程师",
+        start_from: "all",
+        criteria: "全部候选人都过一遍",
+        targetCount: { targetCount: "all" }
+      }
+    });
+    assert.equal(startedCamelCase.status, "ACCEPTED");
+    assert.equal(readStubState(workspaceRoot).last_start_args.targetCount, "-1");
+
+    const invalidTarget = await startBossChatRun({
+      workspaceRoot,
+      input: {
+        profile: "default",
+        job: "算法工程师",
+        start_from: "all",
+        criteria: "全部候选人都过一遍",
+        target_count: "not a target"
+      }
+    });
+    assert.equal(invalidTarget.status, "NEED_INPUT");
+    assert.deepEqual(invalidTarget.missing_fields, ["target_count"]);
+    assert.equal(invalidTarget.received_target_count, "not a target");
+    assert.equal(Boolean(invalidTarget.target_count_parse_error), true);
+    assert.equal(invalidTarget.next_call_example.target_count, "all");
+    assert.equal(invalidTarget.accepted_examples.includes("all"), true);
+
     const running = await getBossChatRun({
       workspaceRoot,
       input: {
@@ -323,7 +371,9 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     const prepareToolSchema = tools.find((item) => item.name === TOOL_BOSS_CHAT_PREPARE_RUN).inputSchema;
     const startToolSchema = tools.find((item) => item.name === TOOL_BOSS_CHAT_START_RUN).inputSchema;
     assert.equal(prepareToolSchema.required, undefined);
-    assert.deepEqual(startToolSchema.required, ["job", "start_from", "target_count", "criteria"]);
+    assert.deepEqual(startToolSchema.required, ["job", "start_from", "criteria"]);
+    assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("target_count")), true);
+    assert.equal(startToolSchema.anyOf.some((item) => item.required?.includes("targetCount")), true);
 
     const prepared = await callTool(workspaceRoot, TOOL_BOSS_CHAT_PREPARE_RUN, {}, 101);
     assert.equal(prepared.status, "NEED_INPUT");
@@ -348,6 +398,19 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     assert.equal(missingTargetOnly.status, "NEED_INPUT");
     assert.deepEqual(missingTargetOnly.missing_fields, ["target_count"]);
     assert.equal(missingTargetOnly.next_call_example.target_count, "all");
+    assert.equal(missingTargetOnly.accepted_examples.includes(-1), true);
+
+    const invalidTargetOnly = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
+      job: "算法工程师",
+      start_from: "all",
+      criteria: "全部候选人都过一遍",
+      target_count: "not a target"
+    }, 112);
+    assert.equal(invalidTargetOnly.status, "NEED_INPUT");
+    assert.deepEqual(invalidTargetOnly.missing_fields, ["target_count"]);
+    assert.equal(invalidTargetOnly.received_target_count, "not a target");
+    assert.equal(Boolean(invalidTargetOnly.target_count_parse_error), true);
+    assert.equal(invalidTargetOnly.next_call_example.target_count, "all");
 
     const invalidStartResponse = await handleRequest(
       makeToolCall(11, TOOL_BOSS_CHAT_START_RUN, {
@@ -384,6 +447,15 @@ async function testBossChatMcpToolsShouldValidateAndRoute() {
     const stateAfterStartAll = readStubState(workspaceRoot);
     assert.equal(stateAfterStartAll.last_start_args.targetCount, "-1");
 
+    const startedCamelCase = await callTool(workspaceRoot, TOOL_BOSS_CHAT_START_RUN, {
+      job: "算法工程师",
+      start_from: "all",
+      criteria: "全部候选人都过一遍",
+      targetCount: "all"
+    }, 141);
+    assert.equal(startedCamelCase.status, "ACCEPTED");
+    assert.equal(readStubState(workspaceRoot).last_start_args.targetCount, "-1");
+
     const running = await callTool(workspaceRoot, TOOL_BOSS_CHAT_GET_RUN, {
       run_id: started.run_id,
       profile: "default"
@@ -481,10 +553,265 @@ async function testBossChatCliShouldSupportRunAndFollowUpParsing() {
   });
 }
 
+function testBossChatLlmEvidenceGateShouldDemoteMissingEvidence() {
+  const parsed = parseLlmJson(
+    JSON.stringify({
+      passed: true,
+      reason: "命中标准",
+      summary: "命中",
+      evidence: [],
+    }),
+    {
+      evidenceCorpus: "南京大学 机器学习 项目经历",
+    },
+  );
+  assert.equal(parsed.rawPassed, true);
+  assert.equal(parsed.passed, false);
+  assert.equal(parsed.evidenceGateDemoted, true);
+  assert.equal(parsed.evidenceMatchedCount, 0);
+}
+
+function testBossChatLlmEvidenceGateShouldDemoteUnmatchedEvidence() {
+  const parsed = parseLlmJson(
+    JSON.stringify({
+      passed: true,
+      reason: "命中标准",
+      summary: "命中",
+      evidence: ["十年金融风控投研经验"],
+    }),
+    {
+      evidenceCorpus: "南京大学 机器学习 项目经历",
+    },
+  );
+  assert.equal(parsed.rawPassed, true);
+  assert.equal(parsed.passed, false);
+  assert.equal(parsed.evidenceGateDemoted, true);
+  assert.equal(parsed.evidenceRawCount, 1);
+  assert.equal(parsed.evidenceMatchedCount, 0);
+}
+
+async function testBossChatLlmTextChunkFallbackShouldWork() {
+  const originalChunkSize = process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS;
+  const originalChunkOverlap = process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS;
+  const originalMaxChunks = process.env.BOSS_CHAT_TEXT_MAX_CHUNKS;
+  process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS = "1000";
+  process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS = "120";
+  process.env.BOSS_CHAT_TEXT_MAX_CHUNKS = "6";
+  try {
+    class FakeChunkFallbackClient extends LlmClient {
+      constructor() {
+        super({
+          baseUrl: "https://api.example.com/v1",
+          apiKey: "sk-test",
+          model: "gpt-test",
+        });
+        this.calls = [];
+      }
+
+      async requestByPreference(payload) {
+        this.calls.push(payload);
+        if (payload.chunkTotal === 1 && !payload.imageDataUrl) {
+          const error = new Error("maximum context length exceeded");
+          throw error;
+        }
+        if (payload.chunkTotal > 1) {
+          if (payload.chunkIndex === 2) {
+            return {
+              passed: true,
+              rawPassed: true,
+              reason: "命中分段证据",
+              summary: "命中",
+              evidence: ["PASS_MARKER_ABC"],
+              evidenceRawCount: 1,
+              evidenceMatchedCount: 1,
+              evidenceGateDemoted: false,
+              chunkIndex: payload.chunkIndex,
+              chunkTotal: payload.chunkTotal,
+            };
+          }
+          return {
+            passed: false,
+            rawPassed: false,
+            reason: "本段证据不足",
+            summary: "不足",
+            evidence: [],
+            evidenceRawCount: 0,
+            evidenceMatchedCount: 0,
+            evidenceGateDemoted: false,
+            chunkIndex: payload.chunkIndex,
+            chunkTotal: payload.chunkTotal,
+          };
+        }
+        return {
+          passed: false,
+          rawPassed: false,
+          reason: "unexpected",
+          summary: "unexpected",
+          evidence: [],
+          evidenceRawCount: 0,
+          evidenceMatchedCount: 0,
+          evidenceGateDemoted: false,
+          chunkIndex: 1,
+          chunkTotal: 1,
+        };
+      }
+    }
+
+    const client = new FakeChunkFallbackClient();
+    const longResume = `${"A".repeat(1200)} PASS_MARKER_ABC ${"B".repeat(1200)} PASS_MARKER_DEF`;
+    const result = await client.evaluateResume({
+      screeningCriteria: "有 AI 项目经验",
+      candidate: {
+        name: "候选人A",
+        sourceJob: "算法工程师",
+        resumeText: longResume,
+        evidenceCorpus: longResume,
+      },
+      imagePath: null,
+    });
+    assert.equal(result.passed, true);
+    assert.equal(result.evaluationMode, "text");
+    assert.equal(result.chunkIndex, 2);
+    assert.equal(Number(result.chunkTotal) > 1, true);
+  } finally {
+    if (originalChunkSize === undefined) delete process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS;
+    else process.env.BOSS_CHAT_TEXT_CHUNK_SIZE_CHARS = originalChunkSize;
+    if (originalChunkOverlap === undefined) delete process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS;
+    else process.env.BOSS_CHAT_TEXT_CHUNK_OVERLAP_CHARS = originalChunkOverlap;
+    if (originalMaxChunks === undefined) delete process.env.BOSS_CHAT_TEXT_MAX_CHUNKS;
+    else process.env.BOSS_CHAT_TEXT_MAX_CHUNKS = originalMaxChunks;
+  }
+}
+
+async function testBossChatAppShouldPersistEvidenceArtifacts() {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "boss-chat-artifacts-"));
+  await mkdir(tempDir, { recursive: true });
+  const records = [];
+  const page = {
+    async closeResumeModalDomOnce() {
+      return {
+        closed: true,
+        method: "dom",
+        finalState: { scopeCount: 0, iframeCount: 0, closeCount: 0, topScopeClass: "" },
+      };
+    },
+    async waitForConversationReady() {
+      return {
+        hasOnlineResume: true,
+        hasAskResume: true,
+        hasAttachmentResume: false,
+        attachmentResumeEnabled: false,
+      };
+    },
+    async openOnlineResume() {
+      return { clicked: true, detectedOpen: true, by: "dom" };
+    },
+    async getResumeRateLimitWarning() {
+      return { hit: false, text: "" };
+    },
+    async getResumeProfileFromDom() {
+      return {
+        ok: true,
+        primarySchool: "南京大学",
+        schools: ["南京大学"],
+        major: "计算机",
+        majors: ["计算机"],
+        company: "OpenAI",
+        position: "工程师",
+        resumeText: "南京大学 计算机 PASS_MARKER_ABC",
+        evidenceCorpus: "南京大学 计算机 PASS_MARKER_ABC",
+      };
+    },
+    async getResumeModalState() {
+      return { open: true, iframeCount: 1, scopeCount: 1, closeCount: 1 };
+    },
+  };
+  const llmClient = {
+    async evaluateResume() {
+      return {
+        passed: false,
+        rawPassed: true,
+        reason: "模型未给出可在简历原文中校验的证据，按安全策略判为不通过。",
+        summary: "降级",
+        evidence: [],
+        evidenceRawCount: 1,
+        evidenceMatchedCount: 0,
+        evidenceGateDemoted: true,
+        evaluationMode: "text",
+        chunkIndex: 1,
+        chunkTotal: 1,
+      };
+    },
+  };
+  const interaction = {
+    async sleepRange() {},
+    async clickRect() {},
+  };
+  const resumeCaptureService = {
+    async captureResume({ artifactDir }) {
+      return {
+        stitchedImage: path.join(artifactDir, "resume.png"),
+        metadataFile: path.join(artifactDir, "chunks.json"),
+        chunkDir: path.join(artifactDir, "chunks"),
+        chunkCount: 1,
+        quality: { likelyBlank: false },
+      };
+    },
+  };
+  const stateStore = {
+    async record(_key, result) {
+      records.push(result);
+    },
+  };
+  const app = new BossChatApp({
+    page,
+    llmClient,
+    interaction,
+    resumeCaptureService,
+    stateStore,
+    reportStore: { async write() { return ""; } },
+    dryRun: true,
+    artifactRootDir: tempDir,
+    resumeOpenCooldownMs: 0,
+    logger: { log() {} },
+  });
+  app.waitResumeOpenCooldown = async () => {};
+
+  const result = await app.processCustomer(
+    {
+      customerKey: "candidate-key",
+      name: "候选人A",
+      sourceJob: "算法工程师",
+      domIndex: 0,
+      customerId: "1001",
+      textSnippet: "",
+    },
+    {
+      screeningCriteria: "有 AI 项目经验",
+    },
+    "run-test",
+    { skipCardClick: true },
+  );
+
+  assert.equal(result.passed, false);
+  assert.equal(result.artifacts.rawPassed, true);
+  assert.equal(result.artifacts.finalPassed, false);
+  assert.equal(result.artifacts.evidenceRawCount, 1);
+  assert.equal(result.artifacts.evidenceMatchedCount, 0);
+  assert.equal(result.artifacts.evidenceGateDemoted, true);
+  assert.equal(result.artifacts.evaluationMode, "text");
+  assert.equal(Array.isArray(records), true);
+  assert.equal(records.length, 1);
+}
+
 async function main() {
   await testBossChatAdapterShouldResolveSharedConfigAndInvokeLocalCli();
   await testBossChatMcpToolsShouldValidateAndRoute();
   await testBossChatCliShouldSupportRunAndFollowUpParsing();
+  testBossChatLlmEvidenceGateShouldDemoteMissingEvidence();
+  testBossChatLlmEvidenceGateShouldDemoteUnmatchedEvidence();
+  await testBossChatLlmTextChunkFallbackShouldWork();
+  await testBossChatAppShouldPersistEvidenceArtifacts();
   console.log("boss-chat tests passed");
 }
 

package/src/test-pipeline.js

@@ -2224,6 +2224,94 @@ async function testFollowUpChatMissingTargetCountShouldNeedInput() {
   assert.equal(result.pending_questions.some((item) => item.field === "follow_up.chat.target_count"), true);
 }
 
+async function testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics() {
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: {},
+      overrides: {},
+      followUp: createFollowUpChat({ target_count: "not a target" })
+    },
+    {
+      parseRecommendInstruction: () => createParsed()
+    }
+  );
+
+  assert.equal(result.status, "NEED_INPUT");
+  assert.equal(result.missing_fields.includes("follow_up.chat.target_count"), true);
+  const targetQuestion = result.pending_questions.find((item) => item.field === "follow_up.chat.target_count");
+  assert.equal(targetQuestion?.received_target_count, "not a target");
+  assert.equal(Boolean(targetQuestion?.target_count_parse_error), true);
+  assert.equal(targetQuestion?.accepted_examples.includes("all"), true);
+}
+
+async function testFollowUpChatAllTargetCountShouldLaunchUnlimited() {
+  let capturedChatInput = null;
+  const result = await runRecommendPipeline(
+    {
+      workspaceRoot: process.cwd(),
+      instruction: "test",
+      confirmation: createJobConfirmedConfirmation(),
+      overrides: {},
+      followUp: createFollowUpChat({ target_count: "all" })
+    },
+    {
+      parseRecommendInstruction: () => createParsed(),
+      runPipelinePreflight: () => ({ ok: true, checks: [], debug_port: 9555 }),
+      ensureBossRecommendPageReady: async () => ({ ok: true, state: "RECOMMEND_READY", page_state: {} }),
+      listRecommendJobs: async () => createJobListResult(),
+      readRecommendTabState: async () => ({ ok: true, active_tab_status: "0" }),
+      switchRecommendTab: async () => ({ ok: true, state: "TAB_READY" }),
+      runRecommendSearchCli: async () => ({
+        ok: true,
+        summary: {
+          candidate_count: 8,
+          applied_filters: { degree: ["本科"] },
+          selected_job: DEFAULT_JOB_OPTIONS[0]
+        }
+      }),
+      runRecommendScreenCli: async () => ({
+        ok: true,
+        summary: {
+          processed_count: 6,
+          passed_count: 2,
+          skipped_count: 4,
+          output_csv: "C:/temp/recommend.csv",
+          completion_reason: "screen_completed"
+        }
+      }),
+      startBossChatRun: async ({ input }) => {
+        capturedChatInput = input;
+        return {
+          status: "ACCEPTED",
+          run_id: "chat-run-unlimited",
+          message: "chat started"
+        };
+      },
+      getBossChatRun: async () => ({
+        status: "RUN_STATUS",
+        run: {
+          runId: "chat-run-unlimited",
+          state: "completed",
+          lastMessage: "chat completed",
+          progress: {
+            inspected: 3,
+            passed: 1,
+            requested: 1,
+            skipped: 2,
+            errors: 0
+          }
+        }
+      })
+    }
+  );
+
+  assert.equal(result.status, "COMPLETED");
+  assert.equal(capturedChatInput.target_count, "all");
+  assert.equal(result.follow_up?.chat?.target_count, "all");
+}
+
 async function testFinalReviewShouldIncludeFollowUpChatSummary() {
   const result = await runRecommendPipeline(
     {
@@ -2479,8 +2567,10 @@ async function main() {
   await testFollowUpChatMissingFieldsShouldExposeRecommendDefaults();
   await testFollowUpChatMissingStartFromShouldNeedInput();
   await testFollowUpChatMissingTargetCountShouldNeedInput();
+  await testFollowUpChatInvalidTargetCountShouldNeedInputWithDiagnostics();
   await testFinalReviewShouldIncludeFollowUpChatSummary();
   await testCompletedPipelineShouldRunChatFollowUp();
+  await testFollowUpChatAllTargetCountShouldLaunchUnlimited();
   await testCompletedPipelineShouldFailWhenChatLaunchFails();
   await testCompletedPipelineShouldFailWhenChatRunFails();
   console.log("pipeline tests passed");

package/vendor/boss-chat-cli/src/app.js

@@ -233,7 +233,11 @@ export class BossChatApp {
 
     let consecutiveErrors = 0;
     let exhaustedScrolls = 0;
-    const exhaustedScrollLimit = targetCount ? 3 : 8;
+    let noMoreMarkerHits = 0;
+    let fallbackBottomHits = 0;
+    const noMoreMarkerConfirmations = 2;
+    const exhaustedScrollLimit = targetCount ? 10 : 60;
+    const fallbackBottomLimit = targetCount ? 4 : 12;
 
     try {
       while (shouldContinue(summary, targetCount)) {
@@ -324,6 +328,9 @@ export class BossChatApp {
             stage: 'running',
             message: `已处理候选人：${result.name || '未知'}`,
           });
+          exhaustedScrolls = 0;
+          noMoreMarkerHits = 0;
+          fallbackBottomHits = 0;
           if (consecutiveErrors >= 3) {
             this.logger.log('连续 3 位候选人处理失败，提前停止本轮运行。');
             break;
@@ -340,13 +347,33 @@ export class BossChatApp {
         if (!nextCustomer) {
           const ratio = 0.52 + Math.random() * 0.34;
           const scrollResult = await this.page.scrollCustomerList(ratio);
+          const noMoreDetected =
+            Boolean(scrollResult.noMoreDetectedAfter) || Boolean(scrollResult.noMoreDetectedBefore);
           this.logger.log(
-            `列表滚动：ratio=${ratio.toFixed(2)} | didScroll=${Boolean(scrollResult.didScroll)} | top=${scrollResult.after?.top ?? 'n/a'} | scrollRetry=${exhaustedScrolls + 1}`,
+            `列表滚动：ratio=${ratio.toFixed(2)} | didScroll=${Boolean(scrollResult.didScroll)} | top=${scrollResult.after?.top ?? 'n/a'} | atBottom=${Boolean(scrollResult.atBottom)} | noMore=${noMoreDetected}${scrollResult.noMoreTextAfter ? `(${scrollResult.noMoreTextAfter})` : ''} | scrollRetry=${exhaustedScrolls + 1}`,
           );
+          if (noMoreDetected) {
+            noMoreMarkerHits += 1;
+            if (noMoreMarkerHits >= noMoreMarkerConfirmations) {
+              summary.exhausted = true;
+              this.logger.log('列表滚动终止：检测到“没有更多了”标识，判定为 exhausted。');
+              break;
+            }
+            await this.interaction.sleepRange(920, 260);
+            continue;
+          }
+
+          noMoreMarkerHits = 0;
           exhaustedScrolls = scrollResult.didScroll ? exhaustedScrolls + 1 : exhaustedScrolls + 2;
+          fallbackBottomHits = scrollResult.atBottom ? fallbackBottomHits + 1 : 0;
+          if (fallbackBottomHits >= fallbackBottomLimit && exhaustedScrolls >= Math.ceil(exhaustedScrollLimit / 2)) {
+            summary.exhausted = true;
+            this.logger.log('列表滚动终止：未发现“没有更多了”标识，但已多次触底且无可处理候选人，判定为 exhausted。');
+            break;
+          }
           if (exhaustedScrolls >= exhaustedScrollLimit) {
             summary.exhausted = true;
-            this.logger.log('列表滚动终止：连续无可处理候选人，判定为 exhausted。');
+            this.logger.log('列表滚动终止：连续无可处理候选人达到保护上限，判定为 exhausted。');
             break;
           }
           await this.interaction.sleepRange(920, 260);
@@ -354,6 +381,8 @@ export class BossChatApp {
         }
 
         exhaustedScrolls = 0;
+        noMoreMarkerHits = 0;
+        fallbackBottomHits = 0;
         this.logger.log(
           `准备处理候选人：name=${nextCustomer.name || '未知'} | key=${nextCustomer.customerKey} | job=${nextCustomer.sourceJob || '未知'} | domIndex=${nextCustomer.domIndex}`,
         );
@@ -578,6 +607,8 @@ export class BossChatApp {
               majors: Array.isArray(resumeProfile.majors) ? resumeProfile.majors : [],
               company: resumeProfile.company || '',
               position: resumeProfile.position || '',
+              resumeTextLength: String(resumeProfile.resumeText || '').length,
+              evidenceCorpusLength: String(resumeProfile.evidenceCorpus || '').length,
             };
           } else {
             this.logger.log(`简历结构化提取未命中：${resumeProfile?.error || 'unknown'}`);
@@ -638,6 +669,8 @@ export class BossChatApp {
             company: resumeProfile.company || '',
             position: resumeProfile.position || '',
           } : null,
+          resumeText: resumeProfile?.ok ? String(resumeProfile.resumeText || '') : '',
+          evidenceCorpus: resumeProfile?.ok ? String(resumeProfile.evidenceCorpus || '') : '',
         },
         imagePath: capture.stitchedImage,
       });
@@ -647,13 +680,37 @@ export class BossChatApp {
           `评估理由学校字段已按主简历纠偏：rawReason=${evaluation.reason} | finalReason=${finalReason}`,
         );
       }
+      if (evaluation.evidenceGateDemoted === true) {
+        this.logger.log(
+          `证据闸门降级：rawPassed=${Boolean(evaluation.rawPassed)} | evidenceRawCount=${Number(evaluation.evidenceRawCount || 0)} | evidenceMatchedCount=${Number(evaluation.evidenceMatchedCount || 0)} | mode=${evaluation.evaluationMode || 'unknown'}`,
+        );
+      }
       this.logger.log(
-        `LLM评估完成：passed=${evaluation.passed} | reason=${finalReason}`,
+        `LLM评估完成：passed=${evaluation.passed} | rawPassed=${Boolean(evaluation.rawPassed)} | mode=${evaluation.evaluationMode || 'unknown'} | reason=${finalReason}`,
       );
 
       baseResult.reason = finalReason;
       baseResult.passed = evaluation.passed;
       baseResult.decision = evaluation.passed ? 'passed' : 'skipped';
+      baseResult.artifacts.rawPassed = Boolean(evaluation.rawPassed);
+      baseResult.artifacts.finalPassed = Boolean(evaluation.passed);
+      baseResult.artifacts.evidenceRawCount = Number.isFinite(Number(evaluation.evidenceRawCount))
+        ? Number(evaluation.evidenceRawCount)
+        : 0;
+      baseResult.artifacts.evidenceMatchedCount = Number.isFinite(Number(evaluation.evidenceMatchedCount))
+        ? Number(evaluation.evidenceMatchedCount)
+        : 0;
+      baseResult.artifacts.evidenceGateDemoted = evaluation.evidenceGateDemoted === true;
+      baseResult.artifacts.evaluationMode = String(evaluation.evaluationMode || '');
+      baseResult.artifacts.evaluationChunkIndex = Number.isFinite(Number(evaluation.chunkIndex))
+        ? Number(evaluation.chunkIndex)
+        : null;
+      baseResult.artifacts.evaluationChunkTotal = Number.isFinite(Number(evaluation.chunkTotal))
+        ? Number(evaluation.chunkTotal)
+        : null;
+      baseResult.artifacts.evaluationEvidence = Array.isArray(evaluation.evidence)
+        ? evaluation.evidence.slice(0, 5).map((item) => String(item || '').trim()).filter(Boolean)
+        : [];
 
       await this.checkpoint();
       const closeResult =