Jesse_Chen
1351 lines
47 KiB
TypeScript
1351 lines
47 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { readFileSync } from "node:fs";
|
|
import test from "node:test";
|
|
import {
|
|
buildProductionConversationalRectificationPacket,
|
|
conversationMessagesFromStoredTurns,
|
|
createBirthTimeConversationPostHandler,
|
|
declaredBirthInputForLegacyCase,
|
|
loadProductionConversationalRectificationProfile,
|
|
rectificationNarrativeTextFromMastraResult,
|
|
resolveRectificationNarrativeModels,
|
|
resolveMissingProfileTimezoneOffset,
|
|
type BirthTimeConversationRouteService,
|
|
} from "../src/app/api/birth-time-conversation/handler.ts";
|
|
import { ConversationalRectificationError } from "../src/lib/conversational-rectification/errors.ts";
|
|
import type {
|
|
BirthTimeJourneyEngine,
|
|
DifferencePacketInput,
|
|
} from "../src/lib/birth-time-journey-service.ts";
|
|
import type { LifeEventEvidence } from "../src/lib/conversational-rectification/persistence-contracts.ts";
|
|
import type { CandidateResult, LifeEvent } from "../src/lib/birth-time-evidence.ts";
|
|
|
|
const userId = "00000000-0000-4000-8000-000000000711";
|
|
const actionId = "00000000-0000-4000-8000-000000000712";
|
|
const caseId = "00000000-0000-4000-8000-000000000713";
|
|
const requestId = "00000000-0000-4000-8000-000000000714";
|
|
|
|
test("production narrator loads the Jyotish Skill without overriding packet truth", () => {
|
|
const source = readFileSync(new URL("../src/app/api/birth-time-conversation/handler.ts", import.meta.url), "utf8");
|
|
|
|
assert.match(source, /skills:\s*\[jyotishSkillPath\]/);
|
|
assert.match(source, /Load the Jyotish Skill to choose a natural, one-question-at-a-time evidence strategy/);
|
|
assert.match(source, /explain the supplied expert workflow/);
|
|
assert.match(source, /supplied packet facts as the exclusive source/);
|
|
assert.match(source, /blocked or not_evaluated technique must never be described as used/);
|
|
assert.match(source, /Never expose internal event classifications, domain labels, scores, weights, or routing metadata/);
|
|
assert.match(source, /on collecting turns, keep the reply conversational and ask exactly one next question/);
|
|
assert.match(source, /Never invent, recalculate, or confirm candidate data/);
|
|
assert.match(source, /schema:\s*rectificationNarrativeAuthoredOutputSchema/);
|
|
assert.match(source, /RECTIFICATION_NARRATIVE_RETRY_MODEL_ID/);
|
|
assert.match(source, /deepseek-v4-flash/);
|
|
assert.match(source, /options\?\.attempt === 2 \? retryModel : preferredModel/);
|
|
});
|
|
|
|
test("rectification narrator prefers the model selected in the session UI", () => {
|
|
const models = new Map([
|
|
["gpt-5-5", { id: "gpt-5-5" }],
|
|
["deepseek-v4-pro", { id: "deepseek-v4-pro" }],
|
|
["deepseek-v4-flash", { id: "deepseek-v4-flash" }],
|
|
]);
|
|
const selected = resolveRectificationNarrativeModels({
|
|
requestedModelId: "gpt-5-5",
|
|
configuredPreferredModelId: "deepseek-v4-pro",
|
|
configuredRetryModelId: "deepseek-v4-flash",
|
|
resolveModel: (modelId) => models.get(modelId) ?? null,
|
|
defaultModel: () => models.get("deepseek-v4-pro") ?? null,
|
|
});
|
|
|
|
assert.equal(selected?.preferredModel.id, "gpt-5-5");
|
|
assert.equal(selected?.retryModel.id, "deepseek-v4-flash");
|
|
});
|
|
|
|
test("rectification narrator rejects a stale or unavailable selected model", () => {
|
|
assert.throws(
|
|
() => resolveRectificationNarrativeModels({
|
|
requestedModelId: "removed-model",
|
|
configuredPreferredModelId: "deepseek-v4-pro",
|
|
configuredRetryModelId: "deepseek-v4-flash",
|
|
resolveModel: () => null,
|
|
defaultModel: () => ({ id: "default-model" }),
|
|
}),
|
|
(error: unknown) => error instanceof ConversationalRectificationError
|
|
&& error.code === "model_unavailable",
|
|
);
|
|
});
|
|
|
|
test("production narrator accepts provider JSON text when Mastra leaves result.object empty", () => {
|
|
const text = '{"narrative":"自然首轮回答"}';
|
|
assert.equal(rectificationNarrativeTextFromMastraResult({ object: undefined, text }), text);
|
|
});
|
|
|
|
test("production narrator preserves timeout classification when Mastra resolves empty after abort", () => {
|
|
const controller = new AbortController();
|
|
const timeout = new DOMException("The operation was aborted due to timeout", "TimeoutError");
|
|
controller.abort(timeout);
|
|
|
|
assert.throws(
|
|
() => rectificationNarrativeTextFromMastraResult(
|
|
{ object: undefined, text: undefined },
|
|
controller.signal,
|
|
),
|
|
(error) => error === timeout,
|
|
);
|
|
});
|
|
|
|
const turn = {
|
|
caseId,
|
|
journeyProtocol: "conversational-evidence-v3" as const,
|
|
status: "active" as const,
|
|
turnVersion: 2,
|
|
narrative: "这是经过服务端验证的合成校正解释。",
|
|
candidate: {
|
|
status: "pending_validation" as const,
|
|
representativeTime: "05:20",
|
|
rangeStart: "05:10",
|
|
rangeEnd: "05:30",
|
|
},
|
|
technicalReceipt: {
|
|
calculationVersion: "rectification-technical-v1",
|
|
stableLayers: ["D1"],
|
|
sensitiveLayers: ["D9", "D10"],
|
|
candidateDifferenceRefs: ["consult-d9", "consult-d10"],
|
|
},
|
|
evidenceRequest: {
|
|
domains: ["relationship" as const, "career" as const],
|
|
datePrecision: "month_preferred" as const,
|
|
freeTextAllowed: true as const,
|
|
},
|
|
evidenceRecap: [],
|
|
actions: ["answer" as const, "pause" as const, "abandon" as const],
|
|
pendingConsultationQuestion: null,
|
|
};
|
|
|
|
test("stored turn history is restored as real alternating Agent and user messages", () => {
|
|
const messages = conversationMessagesFromStoredTurns([
|
|
{ id: "turn-0", turn_version: 0, narrative: "请先告诉我一件时间明确的重要经历。" },
|
|
{ id: "turn-1", turn_version: 1, narrative: "大学毕业已经记下。下一步核对职业事件。" },
|
|
{ id: "turn-2", turn_version: 2, narrative: "职业起点已经记下。下一步核对关系事件。" },
|
|
], [
|
|
{ source_turn_id: "turn-1", raw_text: "2014 年 6 月大学毕业。" },
|
|
{ source_turn_id: "turn-1", raw_text: "2014 年 6 月大学毕业。" },
|
|
{ source_turn_id: "turn-2", raw_text: "2017 年 7 月入职第一家公司。" },
|
|
]);
|
|
|
|
assert.deepEqual(messages, [
|
|
{ role: "assistant", text: "请先告诉我一件时间明确的重要经历。" },
|
|
{ role: "user", text: "2014 年 6 月大学毕业。" },
|
|
{ role: "assistant", text: "大学毕业已经记下。下一步核对职业事件。" },
|
|
{ role: "user", text: "2017 年 7 月入职第一家公司。" },
|
|
{ role: "assistant", text: "职业起点已经记下。下一步核对关系事件。" },
|
|
]);
|
|
});
|
|
|
|
function request(body: unknown, events: string[]) {
|
|
return {
|
|
headers: new Headers({ "x-request-id": requestId }),
|
|
async json() {
|
|
events.push("body");
|
|
return body;
|
|
},
|
|
} as Request;
|
|
}
|
|
|
|
function service(overrides: Partial<BirthTimeConversationRouteService> = {}): BirthTimeConversationRouteService {
|
|
const response = async () => turn;
|
|
return {
|
|
importLegacyCase: response,
|
|
start: response,
|
|
resume: response,
|
|
answer: response,
|
|
regenerate: response,
|
|
pause: response,
|
|
abandon: response,
|
|
confirm: response,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function syntheticEvidence(
|
|
index: number,
|
|
domain: LifeEventEvidence["domain"],
|
|
dateValue = `${2010 + index}-07`,
|
|
datePrecision: LifeEventEvidence["datePrecision"] = "month",
|
|
): LifeEventEvidence {
|
|
return {
|
|
id: `00000000-0000-4000-8000-${String(800 + index).padStart(12, "0")}`,
|
|
rawText: `synthetic event ${index}`,
|
|
domain,
|
|
eventSummary: `synthetic summary ${index}`,
|
|
dateValue,
|
|
datePrecision,
|
|
extractionStatus: "clear",
|
|
scoreable: true,
|
|
};
|
|
}
|
|
|
|
function packetEngine(options: {
|
|
readonly scoreCalls?: LifeEvent[][];
|
|
readonly differenceCalls?: DifferencePacketInput[];
|
|
readonly scanTimes?: readonly string[];
|
|
readonly scanCalls?: Array<{ readonly birthTime: string; readonly uncertaintyMinutes: number }>;
|
|
readonly scoreResults?: readonly CandidateResult[];
|
|
readonly differenceError?: Error;
|
|
} = {}): BirthTimeJourneyEngine {
|
|
let scoreResultIndex = 0;
|
|
const minute = (value: string) => {
|
|
const [hour = 0, part = 0] = value.slice(-5).split(":").map(Number);
|
|
return hour * 60 + part;
|
|
};
|
|
const clock = (value: number) => {
|
|
const normalized = ((value % 1_440) + 1_440) % 1_440;
|
|
return `${String(Math.floor(normalized / 60)).padStart(2, "0")}:${String(normalized % 60).padStart(2, "0")}`;
|
|
};
|
|
return {
|
|
async scan(input) {
|
|
options.scanCalls?.push({
|
|
birthTime: input.birthTime,
|
|
uncertaintyMinutes: input.uncertaintyMinutes,
|
|
});
|
|
const center = minute(input.birthTime);
|
|
const times = options.scanTimes ?? Array.from(
|
|
{ length: input.uncertaintyMinutes * 2 + 1 },
|
|
(_, index) => clock(center - input.uncertaintyMinutes + index),
|
|
);
|
|
return {
|
|
questionnaire: {
|
|
questions: [],
|
|
samples: times.map((time, index) => ({
|
|
ascendantSign: "Cancer",
|
|
d4Sign: index % 2 === 0 ? "Aries" : "Taurus",
|
|
d9Sign: index % 2 === 0 ? "Gemini" : "Virgo",
|
|
d10Sign: index % 2 === 0 ? "Leo" : "Libra",
|
|
d24Sign: "Sagittarius",
|
|
d30Sign: "Pisces",
|
|
})),
|
|
raw: {
|
|
candidate_scan: {
|
|
samples: times.map((time) => ({ time: `1990-01-01 ${time}` })),
|
|
},
|
|
},
|
|
},
|
|
};
|
|
},
|
|
async score() { throw new Error("unexpected questionnaire score"); },
|
|
async scoreEvents(input) {
|
|
assert.ok(input.events.length >= 1);
|
|
for (const event of input.events) {
|
|
const birthBoundary = event.precision === "year"
|
|
? input.birthDate.slice(0, 4)
|
|
: event.precision === "month"
|
|
? input.birthDate.slice(0, 7)
|
|
: input.birthDate;
|
|
assert.ok(event.date >= birthBoundary, "synthetic scorer rejected pre-birth evidence");
|
|
}
|
|
options.scoreCalls?.push([...input.events]);
|
|
const configured = options.scoreResults?.[scoreResultIndex];
|
|
scoreResultIndex += 1;
|
|
if (configured) return configured;
|
|
return {
|
|
resultId: "00000000-0000-4000-8000-000000000899",
|
|
confidence: "low",
|
|
canApply: false,
|
|
winningSegment: null,
|
|
eventCount: input.events.length,
|
|
domainCount: new Set(input.events.map((event) => event.domain)).size,
|
|
topScore: 1,
|
|
secondScore: 1,
|
|
marginPercent: 0,
|
|
reasons: ["synthetic low result"],
|
|
evidence: [],
|
|
algorithmVersion: "synthetic-event-score-v1",
|
|
};
|
|
},
|
|
async buildDifferencePacket(input) {
|
|
options.differenceCalls?.push(input);
|
|
if (options.differenceError) throw options.differenceError;
|
|
return {
|
|
packet: {
|
|
caseId: input.caseId,
|
|
scoringVersion: "birth-time-choice-scoring-v2",
|
|
currentRange: { startTime: input.startTime, endTime: input.endTime },
|
|
opportunities: [],
|
|
askedQuestionFingerprints: [],
|
|
candidatePartitionFingerprints: [],
|
|
recentRangeHistory: [],
|
|
},
|
|
candidateModel: { version: "birth-time-choice-scoring-v2" },
|
|
scoringPartitions: {},
|
|
};
|
|
},
|
|
async scoreChoices() { throw new Error("unexpected choice score"); },
|
|
};
|
|
}
|
|
|
|
test("production first turn continues when optional candidate differences time out", async () => {
|
|
const built = await buildProductionConversationalRectificationPacket(
|
|
packetEngine({ differenceError: new DOMException("timed out", "TimeoutError") }),
|
|
{
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-22",
|
|
declaredBirthInput: {
|
|
source: "hospital_record",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 2,
|
|
uncertaintyAfterMinutes: 2,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [],
|
|
},
|
|
);
|
|
|
|
assert.equal(built.packet.candidate.status, "pending_validation");
|
|
assert.deepEqual(built.packet.candidate.range, { startTime: "05:18", endTime: "05:22" });
|
|
assert.deepEqual(built.packet.candidateDifferenceRefs.filter((item) => (
|
|
item.startsWith("birth-time-choice-scoring")
|
|
)), []);
|
|
assert.equal(built.packet.suggestedDomains.length >= 2, true);
|
|
});
|
|
|
|
test("production first turn skips the minute-heavy candidate partition call for a full day", async () => {
|
|
const differenceCalls: DifferencePacketInput[] = [];
|
|
const built = await buildProductionConversationalRectificationPacket(
|
|
packetEngine({ differenceCalls }),
|
|
{
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-22",
|
|
declaredBirthInput: {
|
|
source: "unknown",
|
|
birthDate: "1990-01-01",
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [],
|
|
},
|
|
);
|
|
|
|
assert.equal(differenceCalls.length, 0);
|
|
assert.deepEqual(built.packet.candidate.range, { startTime: "00:00", endTime: "23:59" });
|
|
assert.equal(built.packet.suggestedDomains.length >= 2, true);
|
|
});
|
|
|
|
const packetBirthplace = {
|
|
cityCode: "TPE-CITY",
|
|
latitude: 25.0268,
|
|
longitude: 121.5434,
|
|
timezoneOffset: 8,
|
|
};
|
|
|
|
test("authentication happens before body parsing and unauthenticated requests create no privileged service", async () => {
|
|
const events: string[] = [];
|
|
let creates = 0;
|
|
const handler = createBirthTimeConversationPostHandler({
|
|
async authenticate() {
|
|
events.push("auth");
|
|
return null;
|
|
},
|
|
async createService() {
|
|
creates += 1;
|
|
return service();
|
|
},
|
|
createRequestId: () => requestId,
|
|
});
|
|
const response = await handler(request({ type: "start", actionId }, events));
|
|
assert.equal(response.status, 401);
|
|
assert.deepEqual(events, ["auth"]);
|
|
assert.equal(creates, 0);
|
|
assert.deepEqual(await response.json(), {
|
|
code: "authentication_required",
|
|
status: 401,
|
|
error: "请先登录",
|
|
message: "登录后才能继续生时校正。",
|
|
retryable: false,
|
|
});
|
|
});
|
|
|
|
test("strict invalid commands return 400 before admin, billing, or service construction", async () => {
|
|
const events: string[] = [];
|
|
let creates = 0;
|
|
const handler = createBirthTimeConversationPostHandler({
|
|
async authenticate() {
|
|
events.push("auth");
|
|
return { userId, context: null };
|
|
},
|
|
async createService() {
|
|
creates += 1;
|
|
return service();
|
|
},
|
|
createRequestId: () => requestId,
|
|
});
|
|
const response = await handler(request({ type: "start", actionId, price: 0 }, events));
|
|
assert.equal(response.status, 400);
|
|
assert.deepEqual(events, ["auth", "body"]);
|
|
assert.equal(creates, 0);
|
|
assert.equal((await response.json() as { code: string }).code, "invalid_command");
|
|
});
|
|
|
|
test("valid commands dispatch exactly one authenticated service method", async () => {
|
|
const events: string[] = [];
|
|
const calls: unknown[] = [];
|
|
const serviceCommands: unknown[] = [];
|
|
const handler = createBirthTimeConversationPostHandler({
|
|
async authenticate() {
|
|
events.push("auth");
|
|
return { userId, context: { authenticated: true } };
|
|
},
|
|
async createService(_authenticated, command) {
|
|
events.push("service");
|
|
serviceCommands.push(command);
|
|
return service({
|
|
async answer(receivedUserId, command) {
|
|
calls.push([receivedUserId, command]);
|
|
return turn;
|
|
},
|
|
});
|
|
},
|
|
createRequestId: () => requestId,
|
|
});
|
|
const command = {
|
|
type: "answer",
|
|
caseId,
|
|
actionId,
|
|
turnVersion: 1,
|
|
modelId: "gpt-5-5",
|
|
answer: "2021年7月毕业",
|
|
};
|
|
const response = await handler(request(command, events));
|
|
assert.equal(response.status, 200);
|
|
assert.deepEqual(events, ["auth", "body", "service"]);
|
|
assert.deepEqual(serviceCommands, [command]);
|
|
assert.deepEqual(calls, [[userId, command]]);
|
|
assert.deepEqual(await response.json(), turn);
|
|
});
|
|
|
|
test("regenerate dispatches without replaying an answer payload", async () => {
|
|
const events: string[] = [];
|
|
const calls: unknown[] = [];
|
|
const handler = createBirthTimeConversationPostHandler({
|
|
async authenticate() {
|
|
return { userId, context: null };
|
|
},
|
|
async createService() {
|
|
return service({
|
|
async regenerate(receivedUserId, command) {
|
|
calls.push([receivedUserId, command]);
|
|
return { ...turn, turnVersion: 2, narrative: "重新生成后的完整回答。" };
|
|
},
|
|
});
|
|
},
|
|
createRequestId: () => requestId,
|
|
});
|
|
const command = { type: "regenerate", caseId, actionId, turnVersion: 1 };
|
|
|
|
const response = await handler(request(command, events));
|
|
|
|
assert.equal(response.status, 200);
|
|
assert.deepEqual(calls, [[userId, command]]);
|
|
assert.equal((await response.json() as { narrative: string }).narrative, "重新生成后的完整回答。");
|
|
});
|
|
|
|
test("resume includes the durable alternating transcript when the service can restore it", async () => {
|
|
const conversationMessages = [
|
|
{ role: "assistant" as const, text: "请先告诉我一件时间明确的重要经历。" },
|
|
{ role: "user" as const, text: "2014 年 6 月大学毕业。" },
|
|
{ role: "assistant" as const, text: turn.narrative },
|
|
];
|
|
const handler = createBirthTimeConversationPostHandler({
|
|
async authenticate() { return { userId, context: null }; },
|
|
async createService() {
|
|
return service({
|
|
async loadConversationMessages(receivedUserId, receivedCaseId) {
|
|
assert.equal(receivedUserId, userId);
|
|
assert.equal(receivedCaseId, caseId);
|
|
return conversationMessages;
|
|
},
|
|
});
|
|
},
|
|
createRequestId: () => requestId,
|
|
});
|
|
|
|
const response = await handler(request({
|
|
type: "resume",
|
|
caseId,
|
|
actionId,
|
|
turnVersion: 2,
|
|
}, []));
|
|
|
|
assert.equal(response.status, 200);
|
|
assert.deepEqual(await response.json(), { ...turn, conversationMessages });
|
|
});
|
|
|
|
test("known conflicts and unavailable failures use stable safe Chinese responses", async () => {
|
|
for (const [failure, status, code] of [
|
|
[new ConversationalRectificationError("stale_turn"), 409, "stale_turn"],
|
|
[new ConversationalRectificationError("action_conflict"), 409, "action_conflict"],
|
|
[new ConversationalRectificationError("service_unavailable"), 503, "service_unavailable"],
|
|
] as const) {
|
|
const logs: unknown[] = [];
|
|
const handler = createBirthTimeConversationPostHandler({
|
|
async authenticate() { return { userId, context: null }; },
|
|
async createService() {
|
|
return service({ async resume() { throw failure; } });
|
|
},
|
|
createRequestId: () => requestId,
|
|
log: (entry) => logs.push(entry),
|
|
});
|
|
const response = await handler(request({ type: "resume", caseId, actionId, turnVersion: 1 }, []));
|
|
const body = await response.json() as { code: string; error: string; message: string };
|
|
assert.equal(response.status, status);
|
|
assert.equal(body.code, code);
|
|
assert.match(`${body.error}${body.message}`, /校正|服务|进度|稍后|重试/);
|
|
assert.deepEqual(logs, [{ code }]);
|
|
}
|
|
});
|
|
|
|
test("unknown SQL, model, and browser errors are never exposed or logged", async () => {
|
|
const raw = "duplicate key SQL WebKit DOMException model response with token=secret";
|
|
const logs: unknown[] = [];
|
|
const handler = createBirthTimeConversationPostHandler({
|
|
async authenticate() { return { userId, context: null }; },
|
|
async createService() {
|
|
return service({ async pause() { throw new Error(raw); } });
|
|
},
|
|
createRequestId: () => requestId,
|
|
log: (entry) => logs.push(entry),
|
|
});
|
|
const response = await handler(request({ type: "pause", caseId, actionId, turnVersion: 1 }, []));
|
|
const serialized = JSON.stringify(await response.json());
|
|
assert.equal(response.status, 503);
|
|
assert.equal(serialized.includes(raw), false);
|
|
assert.equal(JSON.stringify(logs).includes(raw), false);
|
|
assert.deepEqual(logs, [{ code: "service_unavailable" }]);
|
|
});
|
|
|
|
test("production profile conversion links terminal v3 revisions and owner-bound unfinished legacy imports", async () => {
|
|
const priorId = "00000000-0000-4000-8000-000000000715";
|
|
const profile = {
|
|
birth_date: "1990-01-01",
|
|
reported_birth_time: "04:58:00",
|
|
active_birth_time: "05:21:00",
|
|
birth_time_source: "legacy_import",
|
|
birth_time_period: null,
|
|
birth_time_clue: "synthetic dawn clue",
|
|
uncertainty_before_minutes: 0,
|
|
uncertainty_after_minutes: 0,
|
|
country_code: "TW",
|
|
province_code: "TPE",
|
|
city_code: "TPE-CITY",
|
|
district_code: "DAAN",
|
|
latitude: 25.0268,
|
|
longitude: 121.5434,
|
|
timezone_offset: 8,
|
|
rectification_case_id: priorId,
|
|
};
|
|
for (const [prior, expectedRevision, expectedLegacy] of [
|
|
[{ id: priorId, journey_protocol: "conversational-evidence-v3", status: "completed" }, priorId, null],
|
|
[{ id: priorId, journey_protocol: "conversational-evidence-v3", status: "abandoned" }, priorId, null],
|
|
[{ id: priorId, journey_protocol: "conversational-evidence-v3", status: "active" }, null, null],
|
|
[{ id: priorId, journey_protocol: "dynamic-choice-v2", status: "assessing" }, null, priorId],
|
|
[{ id: priorId, journey_protocol: "dynamic-choice-v2", status: "rectifying" }, null, priorId],
|
|
[{ id: priorId, journey_protocol: "legacy-guided-v1", status: "candidate" }, null, priorId],
|
|
[{ id: priorId, journey_protocol: "legacy-guided-v1", status: "confirming" }, null, priorId],
|
|
[{ id: priorId, journey_protocol: "dynamic-choice-v2", status: "reported" }, null, null],
|
|
[{ id: priorId, journey_protocol: "legacy-guided-v1", status: "starting" }, null, null],
|
|
[{ id: priorId, journey_protocol: "dynamic-choice-v2", status: "active" }, null, null],
|
|
[{ id: priorId, journey_protocol: "legacy-guided-v1", status: "paused" }, null, null],
|
|
[{ id: priorId, journey_protocol: "dynamic-choice-v2", status: "confirmed" }, null, null],
|
|
[{ id: priorId, journey_protocol: "legacy-guided-v1", status: "abandoned" }, null, null],
|
|
[{ id: priorId, journey_protocol: "dynamic-choice-v2", status: null }, null, null],
|
|
[{ id: priorId, journey_protocol: "legacy-guided-v1", status: "unexpected" }, null, null],
|
|
[{ id: actionId, journey_protocol: "dynamic-choice-v2", status: "rectifying" }, null, null],
|
|
] as const) {
|
|
const caseLoads: unknown[] = [];
|
|
const loaded = await loadProductionConversationalRectificationProfile({
|
|
async loadProfile(receivedUserId) {
|
|
assert.equal(receivedUserId, userId);
|
|
return profile;
|
|
},
|
|
async loadRectificationCase(receivedUserId, receivedCaseId) {
|
|
caseLoads.push([receivedUserId, receivedCaseId]);
|
|
return prior;
|
|
},
|
|
}, userId);
|
|
|
|
assert.equal(loaded.revisionOfCaseId, expectedRevision);
|
|
assert.equal(loaded.legacyCaseId, expectedLegacy);
|
|
assert.deepEqual(caseLoads, [[userId, priorId]]);
|
|
assert.equal(loaded.declaredBirthInput.source, "legacy_import");
|
|
assert.equal("reportedTime" in loaded.declaredBirthInput
|
|
? loaded.declaredBirthInput.reportedTime
|
|
: null, "04:58");
|
|
}
|
|
});
|
|
|
|
test("legacy import declaration uses the immutable old case time while preserving current place and clue", () => {
|
|
const declared = declaredBirthInputForLegacyCase({
|
|
birth_date: "1990-01-01",
|
|
reported_birth_time: "06:40:00",
|
|
birth_time_source: "family_exact",
|
|
birth_time_period: null,
|
|
birth_time_clue: "现存账户线索",
|
|
uncertainty_before_minutes: 15,
|
|
uncertainty_after_minutes: 15,
|
|
country_code: "TW",
|
|
province_code: "TPE",
|
|
city_code: "TPE-CITY",
|
|
district_code: "DAAN",
|
|
latitude: 25.0268,
|
|
longitude: 121.5434,
|
|
timezone_offset: 8,
|
|
}, {
|
|
reported_date: "1990-01-01",
|
|
reported_time: "05:20:00",
|
|
source: "approximate",
|
|
reported_period: null,
|
|
uncertainty_before_minutes: 30,
|
|
uncertainty_after_minutes: 30,
|
|
});
|
|
|
|
assert.deepEqual(declared, {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: "现存账户线索",
|
|
birthplace: {
|
|
countryCode: "TW",
|
|
provinceCode: "TPE",
|
|
cityCode: "TPE-CITY",
|
|
districtCode: "DAAN",
|
|
latitude: 25.0268,
|
|
longitude: 121.5434,
|
|
timezoneOffset: 8,
|
|
},
|
|
});
|
|
});
|
|
|
|
test("period-only global profile resolves its historical offset before rectification", async () => {
|
|
const profile = {
|
|
birth_date: "1955-02-24",
|
|
reported_birth_time: null,
|
|
active_birth_time: null,
|
|
birth_time_source: "period_only",
|
|
birth_time_period: "evening",
|
|
birth_time_clue: "大约晚上七点左右，可能前后差四十五分钟。",
|
|
uncertainty_before_minutes: null,
|
|
uncertainty_after_minutes: null,
|
|
birth_place_label: "旧金山, 加利福尼亚州, 美国",
|
|
birth_place_type: "city",
|
|
birth_place_provider: "geoapify",
|
|
birth_place_provider_id: "san-francisco",
|
|
country_code: "US",
|
|
province_code: null,
|
|
city_code: null,
|
|
district_code: null,
|
|
latitude: 37.7879363,
|
|
longitude: -122.4075201,
|
|
timezone_id: "America/Los_Angeles",
|
|
timezone_source: "iana_historical",
|
|
timezone_offset: null,
|
|
rectification_case_id: null,
|
|
};
|
|
let timezoneRequest: Record<string, unknown> | null = null;
|
|
const resolve = (value: unknown) => resolveMissingProfileTimezoneOffset(
|
|
value,
|
|
async (_input, init) => {
|
|
timezoneRequest = JSON.parse(String(init?.body)) as Record<string, unknown>;
|
|
return Response.json({
|
|
available: true,
|
|
timezoneId: "America/Los_Angeles",
|
|
timezoneOffset: -8,
|
|
});
|
|
},
|
|
"http://api:5200",
|
|
);
|
|
const loaded = await loadProductionConversationalRectificationProfile({
|
|
loadProfile: async () => profile,
|
|
loadRectificationCase: async () => null,
|
|
resolveTimezoneOffset: resolve,
|
|
}, userId);
|
|
|
|
assert.deepEqual(timezoneRequest, {
|
|
latitude: 37.7879363,
|
|
longitude: -122.4075201,
|
|
birthDate: "1955-02-24",
|
|
birthTime: "20:30",
|
|
});
|
|
assert.equal(loaded.declaredBirthInput.birthplace.timezoneOffset, -8);
|
|
assert.equal(loaded.declaredBirthInput.birthplace.timezoneId, "America/Los_Angeles");
|
|
assert.equal(loaded.declaredBirthInput.birthplace.latitude, 37.787936);
|
|
assert.equal(loaded.declaredBirthInput.birthplace.longitude, -122.40752);
|
|
assert.equal(loaded.declaredBirthInput.source, "period_only");
|
|
});
|
|
|
|
test("an abandoned imported v3 profile pointer becomes the paid revision base", async () => {
|
|
const importedCaseId = "00000000-0000-4000-8000-000000000120";
|
|
const importedFromCaseId = "00000000-0000-4000-8000-000000000121";
|
|
const loaded = await loadProductionConversationalRectificationProfile({
|
|
async loadProfile() {
|
|
return {
|
|
birth_date: "1990-01-01",
|
|
reported_birth_time: "05:20:00",
|
|
active_birth_time: "04:58:00",
|
|
birth_time_source: "legacy_import",
|
|
birth_time_period: null,
|
|
birth_time_clue: "现存账户线索",
|
|
uncertainty_before_minutes: 0,
|
|
uncertainty_after_minutes: 0,
|
|
country_code: "TW",
|
|
province_code: "TPE",
|
|
city_code: "TPE-CITY",
|
|
district_code: "DAAN",
|
|
latitude: 25.0268,
|
|
longitude: 121.5434,
|
|
timezone_offset: 8,
|
|
rectification_case_id: importedCaseId,
|
|
};
|
|
},
|
|
async loadRectificationCase() {
|
|
return {
|
|
id: importedCaseId,
|
|
journey_protocol: "conversational-evidence-v3",
|
|
status: "abandoned",
|
|
imported_from_case_id: importedFromCaseId,
|
|
};
|
|
},
|
|
}, userId);
|
|
|
|
assert.equal(loaded.revisionOfCaseId, importedCaseId);
|
|
assert.equal(loaded.legacyCaseId, null);
|
|
});
|
|
|
|
test("production unknown-time adapter covers the declared full day with bounded deduplicated scans", async () => {
|
|
const scanCalls: Array<{ birthTime: string; uncertaintyMinutes: number }> = [];
|
|
const minute = (value: string) => {
|
|
const [hour = 0, part = 0] = value.slice(-5).split(":").map(Number);
|
|
return hour * 60 + part;
|
|
};
|
|
const clock = (value: number) => {
|
|
const normalized = ((value % 1_440) + 1_440) % 1_440;
|
|
return `${String(Math.floor(normalized / 60)).padStart(2, "0")}:${String(normalized % 60).padStart(2, "0")}`;
|
|
};
|
|
const engine: BirthTimeJourneyEngine = {
|
|
async scan(input) {
|
|
scanCalls.push({ birthTime: input.birthTime, uncertaintyMinutes: input.uncertaintyMinutes });
|
|
const center = minute(input.birthTime);
|
|
const times = Array.from(
|
|
{ length: input.uncertaintyMinutes * 2 + 1 },
|
|
(_, index) => clock(center - input.uncertaintyMinutes + index),
|
|
);
|
|
return {
|
|
questionnaire: {
|
|
questions: [],
|
|
samples: times.map((time) => {
|
|
const value = minute(time);
|
|
return {
|
|
ascendantSign: "Cancer",
|
|
d4Sign: value < 720 ? "Aries" : "Taurus",
|
|
d9Sign: value < 720 ? "Gemini" : "Virgo",
|
|
d10Sign: value < 720 ? "Leo" : "Libra",
|
|
d24Sign: "Sagittarius",
|
|
d30Sign: "Pisces",
|
|
};
|
|
}),
|
|
raw: {
|
|
candidate_scan: {
|
|
samples: times.map((time) => ({ time: `1990-01-01 ${time}` })),
|
|
},
|
|
},
|
|
},
|
|
};
|
|
},
|
|
async score() { throw new Error("unexpected questionnaire score"); },
|
|
async scoreEvents() { throw new Error("unexpected event score"); },
|
|
async buildDifferencePacket(input) {
|
|
return {
|
|
packet: {
|
|
caseId: input.caseId,
|
|
scoringVersion: "birth-time-choice-scoring-v2",
|
|
currentRange: { startTime: input.startTime, endTime: input.endTime },
|
|
opportunities: [],
|
|
askedQuestionFingerprints: [],
|
|
candidatePartitionFingerprints: [],
|
|
recentRangeHistory: [],
|
|
},
|
|
candidateModel: { version: "birth-time-choice-scoring-v2" },
|
|
scoringPartitions: {},
|
|
};
|
|
},
|
|
async scoreChoices() { throw new Error("unexpected choice score"); },
|
|
};
|
|
|
|
const result = await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "unknown",
|
|
birthDate: "1990-01-01",
|
|
birthTimeClue: null,
|
|
birthplace: {
|
|
cityCode: "TPE-CITY",
|
|
latitude: 25.0268,
|
|
longitude: 121.5434,
|
|
timezoneOffset: 8,
|
|
},
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [],
|
|
});
|
|
|
|
assert.equal(scanCalls.length, 4);
|
|
assert.ok(scanCalls.every((call) => call.uncertaintyMinutes >= 1
|
|
&& call.uncertaintyMinutes <= 180));
|
|
const covered = new Set<number>();
|
|
for (const call of scanCalls) {
|
|
const center = minute(call.birthTime);
|
|
for (let value = center - call.uncertaintyMinutes;
|
|
value <= center + call.uncertaintyMinutes; value += 1) {
|
|
assert.ok(value >= 0 && value <= 1_439, `scan invented minute ${value}`);
|
|
covered.add(value);
|
|
}
|
|
}
|
|
assert.equal(covered.size, 1_440);
|
|
assert.deepEqual(result.packet.candidate.range, { startTime: "00:00", endTime: "23:59" });
|
|
const sampleTimes = result.packet.sensitivityScope.sampleTimes;
|
|
assert.equal(new Set(sampleTimes).size, sampleTimes.length);
|
|
assert.deepEqual(sampleTimes, [...sampleTimes].sort((left, right) => minute(left) - minute(right)));
|
|
});
|
|
|
|
test("production packet rescored after every supported event", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const differenceCalls: DifferencePacketInput[] = [];
|
|
const engine = packetEngine({ scoreCalls, differenceCalls });
|
|
const evidence = [
|
|
syntheticEvidence(1, "education"),
|
|
syntheticEvidence(2, "relocation"),
|
|
syntheticEvidence(3, "career"),
|
|
];
|
|
|
|
for (let count = 1; count <= 3; count += 1) {
|
|
const built = await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: evidence.slice(0, count),
|
|
});
|
|
assert.equal(built.packet.candidate.status, "pending_validation");
|
|
assert.equal(built.resultId, "00000000-0000-4000-8000-000000000899");
|
|
}
|
|
|
|
assert.equal(scoreCalls.length, 3);
|
|
assert.deepEqual(
|
|
scoreCalls.map((events) => events.map((event) => event.id)),
|
|
[evidence.slice(0, 1), evidence.slice(0, 2), evidence].map((items) => items.map((item) => item.id)),
|
|
);
|
|
assert.deepEqual(
|
|
scoreCalls[2]?.map((event) => event.summary),
|
|
evidence.map((item) => item.eventSummary),
|
|
"event scoring must retain the concrete user-reported fact, not only domain and date",
|
|
);
|
|
assert.deepEqual(
|
|
differenceCalls.map((input) => input.events.map((event) => event.id)),
|
|
[evidence.slice(0, 1), evidence.slice(0, 2), evidence].map((items) => items.map((item) => item.id)),
|
|
"every next-question request receives the historical evidence available at that turn",
|
|
);
|
|
});
|
|
|
|
test("production preserves a single-minute winning segment without falling back to the prior range", async () => {
|
|
const scanCalls: Array<{ readonly birthTime: string; readonly uncertaintyMinutes: number }> = [];
|
|
const evidence = [
|
|
syntheticEvidence(11, "education"),
|
|
syntheticEvidence(12, "relocation"),
|
|
syntheticEvidence(13, "career"),
|
|
syntheticEvidence(14, "relationship"),
|
|
];
|
|
const overNarrowed: CandidateResult = {
|
|
resultId: "00000000-0000-4000-8000-000000000897",
|
|
confidence: "high",
|
|
canApply: true,
|
|
winningSegment: {
|
|
startTime: "05:20",
|
|
endTime: "05:20",
|
|
representativeTime: "05:20",
|
|
widthMinutes: 1,
|
|
},
|
|
eventCount: 4,
|
|
domainCount: 4,
|
|
topScore: 10,
|
|
secondScore: 1,
|
|
marginPercent: 90,
|
|
reasons: ["synthetic over-narrowed segment"],
|
|
evidence: evidence.map((item) => ({
|
|
eventId: item.id,
|
|
domain: item.domain as "career" | "education" | "relocation" | "relationship",
|
|
candidateTime: "05:20",
|
|
ruleIds: ["synthetic-rule"],
|
|
points: 1,
|
|
})),
|
|
algorithmVersion: "synthetic-event-score-v1",
|
|
};
|
|
|
|
const built = await buildProductionConversationalRectificationPacket(
|
|
packetEngine({ scanCalls, scoreResults: [overNarrowed] }),
|
|
{
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence,
|
|
},
|
|
);
|
|
|
|
assert.deepEqual(scanCalls, [{
|
|
birthTime: "1990-01-01 05:20",
|
|
uncertaintyMinutes: 1,
|
|
}]);
|
|
assert.deepEqual(built.packet.candidate.range, { startTime: "05:20", endTime: "05:20" });
|
|
assert.equal(built.packet.candidate.status, "ready_for_confirmation");
|
|
assert.equal(built.resultId, overNarrowed.resultId);
|
|
assert.deepEqual(
|
|
built.packet.scoredHistoricalEvidence.map((item) => item.evidenceId),
|
|
evidence.map((item) => item.id),
|
|
);
|
|
});
|
|
|
|
test("legacy import scores inherited events without silently replacing the inherited candidate range", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const inherited = { startTime: "05:10", endTime: "05:50" };
|
|
const inheritedEvidence = [
|
|
syntheticEvidence(1, "career"),
|
|
syntheticEvidence(2, "education"),
|
|
syntheticEvidence(3, "relocation"),
|
|
];
|
|
const scored: CandidateResult = {
|
|
resultId: "00000000-0000-4000-8000-000000000898",
|
|
confidence: "low",
|
|
canApply: false,
|
|
winningSegment: {
|
|
startTime: "05:20",
|
|
endTime: "05:24",
|
|
representativeTime: "05:22",
|
|
widthMinutes: 5,
|
|
},
|
|
eventCount: 3,
|
|
domainCount: 3,
|
|
topScore: 4,
|
|
secondScore: 3,
|
|
marginPercent: 10,
|
|
reasons: ["synthetic narrower scored segment"],
|
|
evidence: inheritedEvidence.map((item) => ({
|
|
eventId: item.id,
|
|
domain: item.domain as "career" | "education" | "relocation",
|
|
candidateTime: "05:22",
|
|
ruleIds: ["synthetic-rule"],
|
|
points: 1,
|
|
})),
|
|
algorithmVersion: "synthetic-event-score-v1",
|
|
};
|
|
const result = await buildProductionConversationalRectificationPacket(
|
|
packetEngine({ scoreCalls, scoreResults: [scored] }),
|
|
{
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: {
|
|
calculationVersion: "legacy-import-range-v1",
|
|
rangeStart: inherited.startTime,
|
|
rangeEnd: inherited.endTime,
|
|
},
|
|
evidence: inheritedEvidence,
|
|
preserveCandidateRange: true,
|
|
},
|
|
);
|
|
|
|
assert.equal(scoreCalls.length, 1, "trusted inherited facts still contribute technical evidence");
|
|
assert.deepEqual(result.packet.candidate.range, inherited);
|
|
assert.equal(result.packet.candidate.status, "pending_validation");
|
|
assert.deepEqual(
|
|
result.packet.scoredHistoricalEvidence.map((item) => item.evidenceId),
|
|
scored.evidence.map((item) => item.eventId),
|
|
);
|
|
});
|
|
|
|
test("production rescans the declared range after correction while ordinary evidence stays incremental", async () => {
|
|
const scanCalls: Array<{ readonly birthTime: string; readonly uncertaintyMinutes: number }> = [];
|
|
const narrowResult: CandidateResult = {
|
|
resultId: "00000000-0000-4000-8000-000000001301",
|
|
confidence: "low",
|
|
canApply: false,
|
|
winningSegment: {
|
|
startTime: "05:16",
|
|
endTime: "05:20",
|
|
representativeTime: "05:18",
|
|
widthMinutes: 5,
|
|
},
|
|
eventCount: 3,
|
|
domainCount: 3,
|
|
topScore: 4,
|
|
secondScore: 3,
|
|
marginPercent: 10,
|
|
reasons: ["synthetic narrowed range"],
|
|
evidence: [],
|
|
algorithmVersion: "synthetic-event-score-v1",
|
|
};
|
|
const broadResult: CandidateResult = {
|
|
...narrowResult,
|
|
resultId: "00000000-0000-4000-8000-000000001302",
|
|
winningSegment: null,
|
|
reasons: ["synthetic evidence no longer narrows the range"],
|
|
};
|
|
const engine = packetEngine({
|
|
scanCalls,
|
|
scoreResults: [narrowResult, broadResult, broadResult],
|
|
});
|
|
const declaredBirthInput = {
|
|
source: "approximate" as const,
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30 as const,
|
|
uncertaintyAfterMinutes: 30 as const,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
};
|
|
const oldEvidence = [
|
|
syntheticEvidence(41, "education"),
|
|
syntheticEvidence(42, "relocation"),
|
|
syntheticEvidence(43, "career"),
|
|
];
|
|
|
|
const narrowed = await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput,
|
|
privateCandidate: null,
|
|
evidence: oldEvidence,
|
|
});
|
|
assert.deepEqual(narrowed.packet.candidate.range, { startTime: "05:16", endTime: "05:20" });
|
|
assert.deepEqual(scanCalls.at(-1), {
|
|
birthTime: "1990-01-01 05:18",
|
|
uncertaintyMinutes: 2,
|
|
});
|
|
|
|
const currentCandidate = {
|
|
calculationVersion: narrowed.packet.calculationVersion,
|
|
rangeStart: narrowed.packet.candidate.range.startTime,
|
|
rangeEnd: narrowed.packet.candidate.range.endTime,
|
|
representativeTime: narrowed.packet.candidate.representativeTime,
|
|
};
|
|
const ordinary = await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput,
|
|
privateCandidate: currentCandidate,
|
|
evidence: [...oldEvidence, syntheticEvidence(44, "relationship")],
|
|
});
|
|
assert.deepEqual(ordinary.packet.candidate.range, { startTime: "05:16", endTime: "05:20" });
|
|
assert.deepEqual(scanCalls.at(-1), {
|
|
birthTime: "1990-01-01 05:18",
|
|
uncertaintyMinutes: 2,
|
|
});
|
|
|
|
const corrected = await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput,
|
|
privateCandidate: null,
|
|
evidence: [
|
|
syntheticEvidence(45, "education"),
|
|
syntheticEvidence(46, "relocation"),
|
|
syntheticEvidence(47, "career"),
|
|
],
|
|
});
|
|
assert.deepEqual(corrected.packet.candidate.range, { startTime: "04:50", endTime: "05:50" });
|
|
assert.deepEqual(scanCalls.at(-1), {
|
|
birthTime: "1990-01-01 05:20",
|
|
uncertaintyMinutes: 30,
|
|
});
|
|
assert.ok(corrected.packet.sensitivityScope.sampleTimes.includes("04:50"));
|
|
assert.equal(ordinary.packet.sensitivityScope.sampleTimes.includes("04:50"), false);
|
|
});
|
|
|
|
test("production packet sends every accumulated event without an eight-event cap", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const differenceCalls: DifferencePacketInput[] = [];
|
|
const engine = packetEngine({ scoreCalls, differenceCalls });
|
|
const domains = ["education", "relocation", "career", "relationship", "health_pressure"] as const;
|
|
const evidence = Array.from({ length: 12 }, (_, index) =>
|
|
syntheticEvidence(index + 1, domains[index % domains.length] ?? "career"));
|
|
|
|
await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence,
|
|
});
|
|
|
|
assert.equal(scoreCalls.length, 1);
|
|
assert.deepEqual(
|
|
scoreCalls[0]?.map((event) => event.id),
|
|
evidence.map((item) => item.id),
|
|
);
|
|
assert.deepEqual(
|
|
differenceCalls.at(-1)?.events.map((event) => event.id),
|
|
evidence.map((item) => item.id),
|
|
);
|
|
assert.ok(scoreCalls[0]?.some((event) => event.domain === "health_pressure"));
|
|
});
|
|
|
|
test("persistable future background evidence never reaches the production scorer", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const engine = packetEngine({ scoreCalls });
|
|
const historical = [
|
|
syntheticEvidence(61, "education", "2018-06", "month"),
|
|
syntheticEvidence(62, "relocation", "2020-09", "month"),
|
|
syntheticEvidence(63, "career", "2024-03", "month"),
|
|
];
|
|
const future = {
|
|
...syntheticEvidence(64, "career", "2027", "year"),
|
|
rawText: "2027年计划换工作",
|
|
eventSummary: "计划换工作",
|
|
scoreable: false as const,
|
|
};
|
|
|
|
await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [...historical, future],
|
|
});
|
|
|
|
assert.deepEqual(scoreCalls.map((events) => events.map((event) => event.id)), [[
|
|
...historical.map((item) => item.id),
|
|
]]);
|
|
});
|
|
|
|
test("family evidence stays out of relationship scoring when three real scorer domains exist", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const engine = packetEngine({ scoreCalls });
|
|
const family = syntheticEvidence(1, "family");
|
|
const supported = [
|
|
syntheticEvidence(2, "education"),
|
|
syntheticEvidence(3, "relocation"),
|
|
syntheticEvidence(4, "career"),
|
|
];
|
|
|
|
await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [family, ...supported],
|
|
});
|
|
|
|
assert.equal(scoreCalls.length, 1);
|
|
assert.deepEqual(scoreCalls[0]?.map((event) => event.domain), [
|
|
"education",
|
|
"relocation",
|
|
"career",
|
|
]);
|
|
assert.equal(scoreCalls[0]?.some((event) => event.id === family.id), false);
|
|
assert.equal(scoreCalls[0]?.some((event) => event.domain === "relationship"), false);
|
|
});
|
|
|
|
test("dated finance evidence reaches the minute scorer without being downgraded to other", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const engine = packetEngine({ scoreCalls });
|
|
|
|
await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "1990-01-01",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [
|
|
syntheticEvidence(71, "education"),
|
|
syntheticEvidence(72, "relocation"),
|
|
syntheticEvidence(73, "finance"),
|
|
],
|
|
});
|
|
|
|
assert.equal(scoreCalls.length, 1);
|
|
assert.deepEqual(scoreCalls[0]?.map((event) => event.domain), [
|
|
"education",
|
|
"relocation",
|
|
"finance",
|
|
]);
|
|
});
|
|
|
|
test("a single period-only scan filters duplicate and out-of-range samples from the exact :59 range", async () => {
|
|
const engine = packetEngine({ scanTimes: ["08:00", "08:01", "10:00", "10:00", "12:00"] });
|
|
const built = await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "period_only",
|
|
birthDate: "1990-01-01",
|
|
reportedPeriod: "morning",
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [],
|
|
});
|
|
|
|
assert.deepEqual(built.packet.candidate.range, { startTime: "08:00", endTime: "11:59" });
|
|
assert.deepEqual(built.packet.sensitivityScope.sampleTimes, ["08:00", "08:01", "10:00"]);
|
|
});
|
|
|
|
test("year-precision evidence before birth is excluded while every valid accumulated event scores", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const engine = packetEngine({ scoreCalls });
|
|
const valid = [
|
|
syntheticEvidence(20, "education", "2018", "year"),
|
|
syntheticEvidence(21, "relocation", "2019", "year"),
|
|
];
|
|
const beforeBirth = syntheticEvidence(22, "career", "1999", "year");
|
|
const birthYear = syntheticEvidence(23, "relationship", "2000", "year");
|
|
const input = {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate" as const,
|
|
birthDate: "2000-06-15",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30 as const,
|
|
uncertaintyAfterMinutes: 30 as const,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
};
|
|
|
|
const waiting = await buildProductionConversationalRectificationPacket(engine, {
|
|
...input,
|
|
evidence: [...valid, beforeBirth],
|
|
});
|
|
assert.equal(waiting.resultId, "00000000-0000-4000-8000-000000000899");
|
|
assert.deepEqual(scoreCalls.map((events) => events.map((event) => event.id)), [[
|
|
...valid.map((item) => item.id),
|
|
]]);
|
|
|
|
await buildProductionConversationalRectificationPacket(engine, {
|
|
...input,
|
|
evidence: [...valid, beforeBirth, birthYear],
|
|
});
|
|
assert.deepEqual(scoreCalls.map((events) => events.map((event) => event.id)), [
|
|
valid.map((item) => item.id),
|
|
[...valid.map((item) => item.id), birthYear.id],
|
|
]);
|
|
});
|
|
|
|
test("month-precision evidence excludes the month before birth and accepts the birth month", async () => {
|
|
const scoreCalls: LifeEvent[][] = [];
|
|
const engine = packetEngine({ scoreCalls });
|
|
const valid = [
|
|
syntheticEvidence(30, "education", "2018-01", "month"),
|
|
syntheticEvidence(31, "relocation", "2019-02", "month"),
|
|
];
|
|
const monthBeforeBirth = syntheticEvidence(32, "career", "2000-05", "month");
|
|
const birthMonth = syntheticEvidence(33, "relationship", "2000-06", "month");
|
|
|
|
await buildProductionConversationalRectificationPacket(engine, {
|
|
userId,
|
|
caseId,
|
|
asOfDate: "2026-07-21",
|
|
declaredBirthInput: {
|
|
source: "approximate",
|
|
birthDate: "2000-06-15",
|
|
reportedTime: "05:20",
|
|
uncertaintyBeforeMinutes: 30,
|
|
uncertaintyAfterMinutes: 30,
|
|
birthTimeClue: null,
|
|
birthplace: packetBirthplace,
|
|
},
|
|
privateCandidate: null,
|
|
evidence: [...valid, monthBeforeBirth, birthMonth],
|
|
});
|
|
|
|
assert.deepEqual(scoreCalls.map((events) => events.map((event) => event.id)), [[
|
|
...valid.map((item) => item.id),
|
|
birthMonth.id,
|
|
]]);
|
|
});
|