root/Jyotisha
1
0
Fork 0
Code Issues 32 Pull Requests Actions Packages Projects Releases Wiki Activity

fix(web): isolate rectification answers from tool-step planning text

Browse Source 
Mastra intermediate text-delta was published as answer.delta, then set-focus domain errors reset the attempt and replayed evidence. Publish only the terminal no-tool step, persist the next probe on the server, and ground batch quotes in the source turn.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
Jesse_Chen
2026-08-24 21:26:57 +08:00
co-authored by Cursor
parent 167bdad20d
commit fe87a9ecdb
30 changed files with 1373 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files
frontend/src/app/api/rectification/agent/route.ts
+14 -1
View File
@@ -14,7 +14,7 @@ import { loadRuntimeFeatureFlags } from "@/lib/feature-flags";
import { isProductEnabled } from "@/lib/product-access";
import { resolveSessionLanguageModel } from "@/lib/model-catalog";
import { createAdminSupabaseClient } from "@/lib/supabase/admin";
import { createServerSupabaseClient } from "@/lib/supabase/server";
import { defaultMessageOrigin, isRectificationMessageOrigin } from "@/lib/rectification-agentic/v9/message-origin";
export const runtime = "nodejs";
export const maxDuration = 120;
@@ -31,6 +31,15 @@ const agentRequestSchema = z.object({
probeId: z.string().trim().min(1).max(200).nullable().optional(),
optionId: z.enum(["A", "B", "C", "D"]).optional(),
expectedRevision: z.number().int().min(0).max(10_000).optional(),
origin: z.enum([
"typed",
"suggestion_click",
"choice_click",
"voice_input",
"retry_replay",
"system_recovery",
]).optional(),
clientActionId: z.string().uuid().optional(),
}).strict();
function actionToBudget(action: "opening" | "message" | "read_only"): RectificationAgentAction {
@@ -346,6 +355,10 @@ export async function POST(request: Request) {
requestId,
action: actionToBudget(action),
message: action === "message" ? parsed.data.message ?? "" : null,
messageOrigin: isRectificationMessageOrigin(parsed.data.origin)
? parsed.data.origin
: defaultMessageOrigin(action),
clientActionId: parsed.data.clientActionId ?? requestId,
modelName: selectedModel.id,
skillName: RECTIFICATION_SKILL_NAME,
skillVersion: skillVersion || RECTIFICATION_SKILL_VERSION,
frontend/src/components/rectification-agentic-chat.tsx
+13 -11
View File
@@ -468,6 +468,8 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
action,
modelId: selectedModelId,
...(action === "message" ? { message: trimmed } : {}),
origin: "typed",
clientActionId: requestId,
}),
});
if (!response.ok) {
@@ -527,14 +529,13 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
raw += event.text;
activityTrace = freezeLiveThink(activityTrace);
const settled = settleRectificationSpokenAndThinking(raw, thinkingRaw);
const parsed = parseAgentReply(settled.spoken);
setMessages((current) => current.map((message) => message.renderKey === assistantRenderKey
? {
...message,
text: parsed.text,
text: settled.spoken,
thinkingText: settled.thinking.trim() || undefined,
activityTrace,
state: parsed.text ? "streaming" : "thinking",
state: settled.spoken ? "streaming" : "thinking",
activity: nextActivityView(message.activity, {
phase: "answer-composition",
label: "正在组织回答…",
@@ -639,7 +640,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
}
const settled = settleRectificationSpokenAndThinking(raw, thinkingRaw);
const parsed = parseAgentReply(settled.spoken);
const parsed = completed && !streamFailed ? parseAgentReply(settled.spoken) : { text: "", title: undefined };
const succeeded = completed && !streamFailed && Boolean(parsed.text);
setMessages((current) => current.flatMap((message): RenderMessage[] => {
if (message.renderKey !== assistantRenderKey) return [message];
@@ -656,10 +657,10 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
activity: undefined,
}];
}
if (streamFailed || hasActivityReceipt(completedReceipt) || parsed.text) {
if (streamFailed || hasActivityReceipt(completedReceipt) || settled.spoken.trim()) {
return [{
...message,
text: parsed.text,
text: settled.spoken,
thinkingText: settled.thinking.trim() || undefined,
activityTrace: completeActivityTrace(activityTrace),
state: "settled",
@@ -670,7 +671,7 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
}
return [];
}));
if (!succeeded && parsed.text) {
if (!succeeded && settled.spoken.trim()) {
setError((current) => current || "回答未完成，已保留现有内容；本次不会扣点。");
} else if (!succeeded && runFailedMessage) {
setError((current) => current || runFailedMessage);
@@ -691,18 +692,17 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
: caught instanceof Error && caught.name === "AbortError";
if (aborted) {
const settled = settleRectificationSpokenAndThinking(raw, thinkingRaw);
const parsed = parseAgentReply(settled.spoken);
setMessages((current) => current.flatMap((message): RenderMessage[] => {
if (message.renderKey !== assistantRenderKey) return [message];
if (parsed.text || settled.thinking.trim()) {
if (settled.spoken.trim() || settled.thinking.trim() || hasActivityReceipt(completedReceipt)) {
return [{
...message,
text: parsed.text,
text: settled.spoken,
thinkingText: settled.thinking.trim() || undefined,
activityTrace: completeActivityTrace(activityTrace),
state: "settled",
completedReceipt,
failed: false,
failed: true,
turnId: completedTurnId,
}];
}
@@ -784,6 +784,8 @@ export function RectificationAgenticChat(props: RectificationAgenticChatProps) {
probeId: choiceCard.probe_id,
optionId: optionId === "stop" ? undefined : optionId,
expectedRevision: choiceCard.case_revision ?? 0,
origin: "choice_click",
clientActionId: actionId,
}),
});
const payload = await response.json().catch(() => null);
frontend/src/lib/rectification-agentic/v9/agent-run.ts
+90 -55
View File
@@ -20,6 +20,7 @@ import {
type V9CaseDossier,
} from "./tool-service";
import { RECTIFICATION_SKILL_NAME, RECTIFICATION_SKILL_VERSION } from "./case-status";
import { RECTIFICATION_AGENT_TOOLS } from "./public-receipt";
import { agentGenerationSettings } from "../../agent-generation-settings.ts";
import { toAgentModelFinishReason } from "../../agent-observability.ts";
import {
@@ -36,6 +37,18 @@ import {
} from "./stream-mapping";
import { splitRectificationSpokenAndThinking } from "./spoken-answer";
import { mapModelFinishToErrorCode, userFacingRunFailure } from "./run-diagnostic";
import {
applyStepAnswerChunk,
createStepAnswerState,
flushStepAnswerOnStreamFinish,
} from "./step-answer";
import { composeRectificationTurnNarration, publicNarrationDtoFromDossier } from "./turn-narration";
import {
defaultMessageOrigin,
isRectificationMessageOrigin,
messageContentHash,
type RectificationMessageOrigin,
} from "./message-origin";
export type V9RunBilling = Readonly<{
reserve(): Promise<{ success: boolean; reason?: string; status: number }>;
@@ -50,6 +63,8 @@ export type V9AgentRunOptions = Readonly<{
requestId: string;
action: RectificationAgentAction;
message: string | null;
messageOrigin?: RectificationMessageOrigin;
clientActionId?: string | null;
modelName: string;
skillName?: string;
skillVersion?: string;
@@ -94,16 +109,14 @@ type AttemptOutcome = Readonly<{
attemptId: string;
}>;
const REPEATED_TOOL_CALL_LIMIT = 3;
const REPEATED_TOOL_CALL_LIMIT = 1;
const MAX_ATTEMPTS = 2;
const RETRYABLE_ERROR_CODES = new Set([
"empty_stream",
"stream_aborted",
"stream_unfinished",
"skill_not_loaded",
"skill_not_bound",
"case_not_loaded",
"focus_persistence_failed",
]);
function streamFinishReason(chunk: {
@@ -111,7 +124,9 @@ function streamFinishReason(chunk: {
payload?: { stepResult?: { reason?: unknown }; reason?: unknown };
}): ReturnType<typeof toAgentModelFinishReason> | null {
if (chunk.type !== "finish") return null;
return toAgentModelFinishReason(chunk.payload?.stepResult?.reason ?? chunk.payload?.reason);
const raw = chunk.payload?.stepResult?.reason ?? chunk.payload?.reason;
if (typeof raw !== "string" || !raw.trim()) return null;
return toAgentModelFinishReason(raw);
}
function first(value: unknown): unknown {
@@ -241,6 +256,21 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
throw new RectificationToolServiceError("agentic_rectification_turn_incomplete");
}
try {
await rpcOf(accounting, "record_agentic_rectification_turn_origin", {
p_user_id: userId,
p_case_id: caseId,
p_turn_id: turnId,
p_origin: isRectificationMessageOrigin(options.messageOrigin)
? options.messageOrigin
: defaultMessageOrigin(options.action),
p_client_action_id: options.clientActionId ?? options.requestId,
p_content_hash: messageContentHash(message),
});
} catch {
// Origin is audit metadata; a missing RPC must not fail the turn.
}
const shouldExecute = turnRecord?.should_execute === undefined
? true
: turnRecord.should_execute === true;
@@ -480,7 +510,6 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
let skillBound = true;
let caseLoaded = false;
let toolFailedPending = false;
let intentClassified = false;
let streamFailed = false;
let finished = false;
@@ -545,7 +574,7 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
prepareStep: (input: { stepNumber: number }) => {
activeTools: string[];
toolChoice: "auto";
} | undefined;
};
},
): Promise<{
fullStream: AsyncIterable<{
@@ -574,10 +603,22 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
activeTools: ["rectification-read-case"],
toolChoice: "auto",
}
: undefined,
: {
activeTools: [...RECTIFICATION_AGENT_TOOLS],
toolChoice: "auto",
},
});
let finishReason: ReturnType<typeof toAgentModelFinishReason> | null = null;
const stepAnswer = createStepAnswerState();
const publishSpokenStep = async (pieces: readonly string[]) => {
const spoken = splitRectificationSpokenAndThinking(pieces.join("")).spoken.trim();
if (!spoken || !caseLoaded) return;
answerText += spoken;
answerDeltas.push(spoken);
await emit({ type: "answer.delta", text: spoken });
};
for await (const chunk of result.fullStream) {
const rawToolName = typeof chunk.payload?.toolName === "string" ? chunk.payload.toolName : "";
@@ -596,6 +637,13 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
}
}
const stepEffect = applyStepAnswerChunk(
stepAnswer,
chunk,
isPublicRectificationToolName,
);
if (stepEffect.kind === "publish") await publishSpokenStep(stepEffect.pieces);
const activityEvent = mapStreamChunkToActivity(chunk as never);
if (activityEvent) {
await publish(activityEvent);
@@ -606,11 +654,7 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
await publish(changed);
}
}
if (activityEvent.status === "failed") {
toolFailedPending = true;
toolTerminalStatus.set(activityEvent.tool, activityEvent.status);
} else if (activityEvent.status === "completed") {
toolFailedPending = false;
if (activityEvent.status === "failed" || activityEvent.status === "completed") {
toolTerminalStatus.set(activityEvent.tool, activityEvent.status);
}
}
@@ -631,33 +675,18 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
if (phaseEvent.type === "case.loaded" && !skillBound) {
throw new Error("skill_not_bound");
}
if (phaseEvent.type === "answer.delta") {
const text = phaseEvent.text ?? "";
if (text) {
if (!caseLoaded || toolFailedPending) {
// Process talk before Case load stays off the public stream.
} else if (/[A-Za-z]{4,}/.test(text) && !/[\u4e00-\u9fff]/.test(text)) {
// English-only process talk stays off the spoken channel.
} else {
answerText += text;
answerDeltas.push(text);
await emit({ type: "answer.delta", text });
}
}
} else {
await recordPhase(phaseEvent.type, phaseEvent.tool ?? null);
const key = `${phaseEvent.type}:${phaseEvent.tool ?? ""}:${(phaseEvent.methods ?? []).join(",")}`;
if (!emittedKeys.has(`event:${key}`)) {
emittedKeys.add(`event:${key}`);
await publish(phaseEvent);
}
if (phaseEvent.type === "case.loaded") {
caseLoaded = true;
if (!intentClassified) {
intentClassified = true;
await recordPhase("intent.classified");
await publish({ type: "intent.classified" });
}
await recordPhase(phaseEvent.type, phaseEvent.tool ?? null);
const key = `${phaseEvent.type}:${phaseEvent.tool ?? ""}:${(phaseEvent.methods ?? []).join(",")}`;
if (!emittedKeys.has(`event:${key}`)) {
emittedKeys.add(`event:${key}`);
await publish(phaseEvent);
}
if (phaseEvent.type === "case.loaded") {
caseLoaded = true;
if (!intentClassified) {
intentClassified = true;
await recordPhase("intent.classified");
await publish({ type: "intent.classified" });
}
}
}
@@ -669,6 +698,15 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
}
}
if (finished && !streamFailed) {
const flushReason = finishReason === "length"
? "length"
: finishReason === "stop" || finishReason === "unknown" || finishReason === null
? "stop"
: finishReason;
const flushed = flushStepAnswerOnStreamFinish(stepAnswer, flushReason);
if (flushed.kind === "publish") await publishSpokenStep(flushed.pieces);
}
answerText = splitRectificationSpokenAndThinking(answerText).spoken.trim();
if (!skillBound) return failedAttempt(attemptId, "skill_not_loaded");
@@ -684,22 +722,6 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
if (mapped === "run_timeout") return failedAttempt(attemptId, "run_timeout");
if (streamFailed || abortController.signal.aborted) return failedAttempt(attemptId, mapped ?? "stream_aborted");
if (!finished) return failedAttempt(attemptId, mapped ?? "stream_unfinished");
if (toolTerminalStatus.get("rectification-set-focus") === "failed") {
return {
ok: false,
status: "retryable",
errorCode: "focus_persistence_failed",
usage: { inputTokens: 0, outputTokens: 0 },
answerText: "",
answerDeltas: [],
phases,
toolsUsed: [...toolsUsed],
events,
skillBound,
caseLoaded,
attemptId,
};
}
if (mapped === "answer_truncated") {
return {
ok: false,
@@ -719,6 +741,19 @@ export async function runV9AgentTurn(options: V9AgentRunOptions): Promise<V9Agen
if (mapped === "max_steps" || mapped === "provider_error") {
return failedAttempt(attemptId, mapped);
}
if (!answerText.trim()) {
try {
const latest = await loadV9CaseDossier(accounting, userId, caseId);
const narration = composeRectificationTurnNarration(publicNarrationDtoFromDossier(latest));
if (narration.trim()) {
answerText = narration;
answerDeltas.push(narration);
await emit({ type: "answer.delta", text: narration });
}
} catch {
// Fall through to empty_stream.
}
}
if (!answerText.trim()) return failedAttempt(attemptId, "empty_stream");
const usage = await (result.totalUsage ?? Promise.resolve({ inputTokens: 0, outputTokens: 0 }));
frontend/src/lib/rectification-agentic/v9/choice-card.ts
+22 -3
View File
@@ -1,9 +1,9 @@
/**
* Choice-card contract for birth-time rectification.
*
* The server owns the discriminator frame and the tap chrome (A/B/C/D keys,
* C = neither / D = unsure roles, scoring vs holdout, 先这样). The Agent
* writes the question and all four option labels. The browser never invents
* The server owns the discriminator frame, the question copy, and the tap
* chrome (A/B/C/D keys, C = neither / D = unsure roles, scoring vs holdout,
* 先这样). The Agent does not write choice labels. The browser never invents
* option copy, and never parses A/B/C/D out of assistant prose.
*/
@@ -317,6 +317,25 @@ function clippedCopy(value: unknown, min: number, max: number): string | null {
return text;
}
export function serverOwnedChoiceCopy(frame: RectificationChoiceFrame): AgentChoiceCopy | null {
const prompt = clippedCopy(`${frame.period}，有没有这件事？`, 4, 80)
?? clippedCopy(frame.period, 4, 80);
const optionA = clippedCopy(frame.option_a_hint, 4, 80);
const optionB = clippedCopy(frame.option_b_hint, 4, 80);
const optionC = clippedCopy(frame.neither_label, 4, 80);
const optionD = clippedCopy(frame.unsure_label, 4, 80);
if (!prompt || !optionA || !optionB || !optionC || !optionD) return null;
const labels = [optionA, optionB, optionC, optionD];
if (new Set(labels).size !== labels.length) return null;
return {
prompt,
option_a: optionA,
option_b: optionB,
option_c: optionC,
option_d: optionD,
};
}
export function parseAgentChoiceCopy(value: unknown): AgentChoiceCopy | null {
if (!value || typeof value !== "object") return null;
const row = value as Record<string, unknown>;
frontend/src/lib/rectification-agentic/v9/evidence-quote.ts
+78
View File
@@ -0,0 +1,78 @@
/**
* Ground evidence quotes in the source user turn. The model may propose
* offsets or a quote string; the server always slices the original message.
*/
const QUOTE_PUNCT = /[\s\u3000，。！？、；：“”‘’（）《》·—…,!.;:?]/g;
export function normalizeRectificationQuote(value: string): string {
return value.toLowerCase().replace(QUOTE_PUNCT, "");
}
export type EvidenceQuoteInput = Readonly<{
quote?: string | null;
quoteStart?: number | null;
quoteEnd?: number | null;
}>;
export type ResolvedEvidenceQuote =
| { ok: true; quote: string; quoteStart: number; quoteEnd: number }
| { ok: false; errorCode: "quote_mismatch" };
function sliceByOffsets(source: string, start: number, end: number): ResolvedEvidenceQuote {
if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > source.length || start >= end) {
return { ok: false, errorCode: "quote_mismatch" };
}
const quote = source.slice(start, end);
if (quote.trim().length < 2) return { ok: false, errorCode: "quote_mismatch" };
return { ok: true, quote, quoteStart: start, quoteEnd: end };
}
function sliceByNormalizedQuote(source: string, quote: string): ResolvedEvidenceQuote {
const needle = normalizeRectificationQuote(quote);
if (needle.length < 2) return { ok: false, errorCode: "quote_mismatch" };
const map: number[] = [];
let normalized = "";
for (let index = 0; index < source.length; index += 1) {
const char = source[index] ?? "";
if (QUOTE_PUNCT.test(char)) continue;
normalized += char.toLowerCase();
map.push(index);
}
const at = normalized.indexOf(needle);
if (at < 0) return { ok: false, errorCode: "quote_mismatch" };
const start = map[at];
const last = map[at + needle.length - 1];
if (start === undefined || last === undefined) return { ok: false, errorCode: "quote_mismatch" };
return sliceByOffsets(source, start, last + 1);
}
export function resolveEvidenceQuote(
sourceTurnText: string | null | undefined,
input: EvidenceQuoteInput,
): ResolvedEvidenceQuote {
const source = sourceTurnText ?? "";
if (!source.trim()) return { ok: false, errorCode: "quote_mismatch" };
if (input.quoteStart != null && input.quoteEnd != null) {
return sliceByOffsets(source, input.quoteStart, input.quoteEnd);
}
const quote = typeof input.quote === "string" ? input.quote.trim() : "";
if (!quote) return { ok: false, errorCode: "quote_mismatch" };
return sliceByNormalizedQuote(source, quote);
}
export function publicEvidenceItemStatus(input: {
outcome: string;
idempotent: boolean;
errorCode: string | null;
}): "created" | "already_exists" | "needs_clarification" | "quote_mismatch" | "rejected" {
if (input.errorCode === "quote_not_grounded" || input.errorCode === "quote_mismatch") {
return "quote_mismatch";
}
if (input.idempotent && (input.outcome === "accepted" || input.outcome === "already_exists")) {
return "already_exists";
}
if (input.outcome === "accepted") return "created";
if (input.outcome === "needs_clarification") return "needs_clarification";
return "rejected";
}
frontend/src/lib/rectification-agentic/v9/inference-adapter.ts
+1
View File
@@ -40,6 +40,7 @@ export function askedProbeKeysFromReceipt(
for (const item of answers) {
if (!item || typeof item !== "object") continue;
const row = item as Record<string, unknown>;
if (typeof row.probe_id === "string") keys.push(row.probe_id);
if (typeof row.semantic_key === "string") keys.push(row.semantic_key);
if (typeof row.candidate_split_hash === "string") keys.push(row.candidate_split_hash);
}
frontend/src/lib/rectification-agentic/v9/message-origin.ts
+27
View File
@@ -0,0 +1,27 @@
import { createHash } from "node:crypto";
export const RECTIFICATION_MESSAGE_ORIGINS = [
"typed",
"suggestion_click",
"choice_click",
"voice_input",
"retry_replay",
"system_recovery",
] as const;
export type RectificationMessageOrigin = (typeof RECTIFICATION_MESSAGE_ORIGINS)[number];
export function isRectificationMessageOrigin(value: unknown): value is RectificationMessageOrigin {
return typeof value === "string"
&& (RECTIFICATION_MESSAGE_ORIGINS as readonly string[]).includes(value);
}
export function defaultMessageOrigin(action: string): RectificationMessageOrigin {
if (action === "answer_choice" || action === "stop_and_review") return "choice_click";
if (action === "opening") return "system_recovery";
return "typed";
}
export function messageContentHash(text: string | null | undefined): string {
return createHash("sha256").update(text ?? "").digest("hex");
}
frontend/src/lib/rectification-agentic/v9/method-followup.ts
+3 -3
View File
@@ -293,11 +293,11 @@ function coverage(
}
function collectHint(why: string, varga: string, extra = ""): string {
return `${why}本题绑定 ${varga}。${extra}用自然语言问一件带大概年份的经历。set-focus 不要写 expectedAnswerSchema.choice，界面不出点选卡。允许模糊年份。`.replace(/\s+/g, " ").trim();
return `${why}本题绑定 ${varga}。${extra}用自然语言问一件带大概年份的经历。不要调用 set-focus，界面不出点选卡。允许模糊年份。`.replace(/\s+/g, " ").trim();
}
function agentHint(why: string, varga: string, extra = ""): string {
return `${why}本题绑定 ${varga}。${extra}根据 choice_frame 自己写题干和 A/B/C/D，经 set-focus.expectedAnswerSchema.choice 交给点选卡。题干由你写成自然语言；年份和事件家族以 choice_frame.period 与探针为准，不得发明年份，不要照抄 hint。A 是这件事大概就在那段时间，B 是有类似但年份不对或不够重大，C 是没有明显发生，D 是不记得。正文不要复述选项。`.replace(/\s+/g, " ").trim();
return `${why}本题绑定 ${varga}。${extra}点选卡已由服务器按 choice_frame 持久化。用简体中文只问这一句已持久化的题干；年份和事件家族以 choice_frame.period 与探针为准，不得发明年份。不要调用 set-focus。正文不要复述选项。`.replace(/\s+/g, " ").trim();
}
export function shouldAttachChoiceFrame(
@@ -634,7 +634,7 @@ export function buildMethodFollowupPlan(input: {
domain: focus.targetDomain,
kind_hint: focus.targetKind,
user_prompt_hint: keepChoice
? "先承接当前服务器焦点。根据 choice_frame 自己写题干和 A/B/C/D，经 set-focus.expectedAnswerSchema.choice 交给点选卡；年份不得发明，不要照抄 hint。正文不要复述选项。"
? "先承接当前服务器已持久化的焦点和点选卡。用简体中文只问这一句；年份不得发明。不要调用 set-focus。正文不要复述选项。"
: "先承接当前服务器焦点。若用户已说带年份的经历，走 batch 写入；否则继续用自然语言问一件带大概年份的事。不要写 expectedAnswerSchema.choice。",
source: "active_focus",
}, true, keepChoice),
frontend/src/lib/rectification-agentic/v9/public-receipt.ts
+5
View File
@@ -54,6 +54,10 @@ export const PUBLIC_RECTIFICATION_TOOLS = [
export type PublicRectificationTool =
(typeof PUBLIC_RECTIFICATION_TOOLS)[number];
export const RECTIFICATION_AGENT_TOOLS = PUBLIC_RECTIFICATION_TOOLS.filter(
(tool) => tool !== "rectification-set-focus",
);
export const PUBLIC_RECTIFICATION_METHODS = [
"d1-rashi",
"d2-hora",
@@ -115,6 +119,7 @@ export type RectificationActivityEvent = Readonly<{
tool: PublicRectificationTool;
status: RectificationActivityStatus;
methods?: readonly PublicRectificationMethod[];
code?: string;
}>;
export const RECEIPT_STATUSES = [
frontend/src/lib/rectification-agentic/v9/server-focus.ts
+157
View File
@@ -0,0 +1,157 @@
import {
serverOwnedChoiceCopy,
type RectificationChoiceFrame,
} from "./choice-card";
import {
askedProbeKeysFromReceipt,
stampChoiceSchemaWithProbe,
previousInferenceFromReceipt,
} from "./inference-adapter";
import type { MethodFollowup } from "./method-followup";
import {
setV10ConversationFocus,
RectificationToolServiceError,
safeToolErrorCode,
type AccountingClient,
type ConversationFocus,
} from "./tool-service";
export type PersistServerFocusStatus =
| "created"
| "already_open"
| "duplicate_focus"
| "probe_already_answered"
| "zero_information_gain"
| "skipped";
export type PersistServerFocusResult = Readonly<{
status: PersistServerFocusStatus;
focus: ConversationFocus | null;
questionId: string | null;
prompt: string | null;
}>;
export function stableFollowupQuestionId(followup: MethodFollowup): string {
if (followup.semantic_key) return `probe:${followup.semantic_key}`.slice(0, 160);
if (followup.probe_year && followup.domain) {
return `${followup.method_id}:${followup.domain}:${followup.probe_year}`.slice(0, 160);
}
return (followup.choice_frame?.question_id ?? `${followup.method_id}:${followup.ask_theme}`).slice(0, 160);
}
function schemaProbeId(schema: Readonly<Record<string, unknown>> | null | undefined): string | null {
const probeId = schema?.probe_id;
return typeof probeId === "string" && probeId.trim() ? probeId : null;
}
export function shouldSkipDiscriminatorFollowup(followup: MethodFollowup): PersistServerFocusStatus | null {
if (followup.source === "event_probe" && (followup.information_gain ?? 0) <= 0) {
return "zero_information_gain";
}
return null;
}
function expectedAnswerSchemaFor(
frame: RectificationChoiceFrame,
questionId: string,
decisionReceipt: Readonly<Record<string, unknown>> | null | undefined,
): Record<string, unknown> | null {
const copy = serverOwnedChoiceCopy(frame);
if (!copy) return null;
const schema: Record<string, unknown> = {
choice: {
prompt: copy.prompt,
option_a: copy.option_a,
option_b: copy.option_b,
option_c: copy.option_c,
option_d: copy.option_d,
},
};
return stampChoiceSchemaWithProbe(
schema,
previousInferenceFromReceipt(decisionReceipt ?? null),
questionId,
);
}
export async function persistServerOwnedFocus(input: {
accounting: AccountingClient;
userId: string;
caseId: string;
activeFocus: ConversationFocus | null;
decisionReceipt: Readonly<Record<string, unknown>> | null | undefined;
followup: MethodFollowup | null;
}): Promise<PersistServerFocusResult> {
const followup = input.followup;
const frame = followup?.choice_frame ?? null;
if (!followup || !frame) {
return { status: "skipped", focus: input.activeFocus, questionId: null, prompt: null };
}
const skip = shouldSkipDiscriminatorFollowup(followup);
if (skip) {
return { status: skip, focus: input.activeFocus, questionId: null, prompt: null };
}
const questionId = stableFollowupQuestionId(followup);
const schema = expectedAnswerSchemaFor(frame, questionId, input.decisionReceipt);
if (!schema?.choice) {
return { status: "skipped", focus: input.activeFocus, questionId, prompt: null };
}
const copy = serverOwnedChoiceCopy(frame);
const prompt = copy?.prompt ?? null;
const answeredKeys = new Set(askedProbeKeysFromReceipt(input.decisionReceipt));
if (followup.semantic_key && answeredKeys.has(followup.semantic_key)) {
return {
status: "probe_already_answered",
focus: input.activeFocus,
questionId,
prompt: null,
};
}
const active = input.activeFocus;
if (
active
&& (
active.questionId === questionId
|| (schemaProbeId(schema) && schemaProbeId(active.expectedAnswerSchema) === schemaProbeId(schema))
)
) {
return { status: "already_open", focus: active, questionId: active.questionId, prompt };
}
if (followup.source === "event_probe" && !schemaProbeId(schema)) {
return {
status: "probe_already_answered",
focus: input.activeFocus,
questionId,
prompt: null,
};
}
try {
const result = await setV10ConversationFocus(input.accounting, input.userId, input.caseId, {
questionId,
intent: followup.intent,
targetEvidenceId: null,
targetDomain: followup.domain,
targetKind: null,
expectedAnswerSchema: schema,
});
return {
status: result.idempotent ? "already_open" : "created",
focus: result.focus,
questionId: result.focus.questionId,
prompt,
};
} catch (error) {
const code = error instanceof RectificationToolServiceError
? error.code
: safeToolErrorCode(error);
if (code === "focus_idempotency_conflict" || code.includes("focus_idempotency_conflict")) {
return {
status: "duplicate_focus",
focus: input.activeFocus,
questionId,
prompt,
};
}
throw error;
}
}
frontend/src/lib/rectification-agentic/v9/step-answer.ts
+123
View File
@@ -0,0 +1,123 @@
/**
* Isolate the terminal no-tool step from Mastra multi-step agent runs.
*
* `text-delta` is not a user answer. A tool-using step may emit planning
* prose before the call; that text must be discarded as a whole. Only a
* step that never called a public tool and finished with `stop` may become
* `answer.delta`.
*/
export type StepAnswerChunk = Readonly<{
type: string;
payload?: {
text?: unknown;
toolName?: unknown;
stepResult?: { reason?: unknown };
reason?: unknown;
};
}>;
export type StepAnswerState = {
text: string;
pieces: string[];
calledTool: boolean;
};
export type StepAnswerEffect =
| { kind: "none" }
| { kind: "discard" }
| { kind: "publish"; pieces: readonly string[] };
function reset(state: StepAnswerState): void {
state.text = "";
state.pieces = [];
state.calledTool = false;
}
export function createStepAnswerState(): StepAnswerState {
return { text: "", pieces: [], calledTool: false };
}
export function stepFinishReason(chunk: StepAnswerChunk): string | null {
if (chunk.type !== "step-finish" && chunk.type !== "finish") return null;
const raw = chunk.payload?.stepResult?.reason ?? chunk.payload?.reason;
return typeof raw === "string" && raw.trim() ? raw.trim() : null;
}
export function shouldPublishStepText(
state: Pick<StepAnswerState, "calledTool" | "text">,
reason: string | null,
): boolean {
if (state.calledTool) return false;
if (!state.text.trim()) return false;
return reason === "stop" || reason === "length" || reason === null;
}
function isPublicToolCall(
chunk: StepAnswerChunk,
isPublicTool: (name: string) => boolean,
): boolean {
const name = typeof chunk.payload?.toolName === "string" ? chunk.payload.toolName : "";
return Boolean(name) && name !== "skill" && isPublicTool(name);
}
/**
* Advance the per-step buffer. Publishing happens only on `step-finish`
* (or a later `flushStepAnswerOnStreamFinish` when Mastra omitted it).
* Tool-result ends the current step so later text is a new step.
*/
export function applyStepAnswerChunk(
state: StepAnswerState,
chunk: StepAnswerChunk,
isPublicTool: (name: string) => boolean,
): StepAnswerEffect {
switch (chunk.type) {
case "reasoning-start":
case "reasoning-delta":
case "reasoning-end":
return { kind: "none" };
case "step-start":
reset(state);
return { kind: "none" };
case "text-delta": {
const text = typeof chunk.payload?.text === "string" ? chunk.payload.text : "";
if (text) {
state.text += text;
state.pieces.push(text);
}
return { kind: "none" };
}
case "tool-call":
if (isPublicToolCall(chunk, isPublicTool)) state.calledTool = true;
return { kind: "none" };
case "tool-result":
case "tool-error": {
if (isPublicToolCall(chunk, isPublicTool)) state.calledTool = true;
const discarded = state.calledTool || state.text.length > 0;
reset(state);
return discarded ? { kind: "discard" } : { kind: "none" };
}
case "step-finish": {
const reason = stepFinishReason(chunk);
const publish = shouldPublishStepText(state, reason);
const pieces = publish ? [...state.pieces] : [];
reset(state);
return publish ? { kind: "publish", pieces } : { kind: "discard" };
}
default:
return { kind: "none" };
}
}
export function flushStepAnswerOnStreamFinish(
state: StepAnswerState,
finishReason: string | null,
): StepAnswerEffect {
if (!shouldPublishStepText(state, finishReason === "stop" || finishReason === null ? "stop" : finishReason)) {
reset(state);
return { kind: "none" };
}
const pieces = [...state.pieces];
reset(state);
return { kind: "publish", pieces };
}
frontend/src/lib/rectification-agentic/v9/stream-mapping.ts
+42 -6
View File
@@ -144,11 +144,8 @@ export function mapStreamChunkToPhase(chunk: AgentChunkType): PublicPhaseStreamE
const methods = METHOD_TOOLS.has(toolName) ? resultMethods(chunk) : [];
return phase ? { type: phase, tool: toolName, ...(methods.length > 0 ? { methods } : {}) } : null;
}
case "text-delta": {
const text = typeof chunk.payload?.text === "string" ? chunk.payload.text : "";
if (!text) return null;
return { type: "answer.delta", text };
}
case "text-delta":
return null;
case "finish":
// Completion is decided by the runner after the skill/first-turn gates;
// a finish chunk alone never proves a settled answer.
@@ -186,6 +183,34 @@ export function mapStreamChunkToThinking(chunk: AgentChunkType): InternalThinkin
* deliberately separate from the durable phase receipt: it never exposes
* args, results, provider errors, scores, birth data or permission flags.
*/
const SAFE_TOOL_ACTIVITY_CODES = new Set([
"duplicate_focus",
"probe_already_answered",
"stale_revision",
"quote_mismatch",
"quote_not_grounded",
"zero_information_gain",
"invalid_tool_input",
"invalid_choice_copy",
"already_exists",
"focus_idempotency_conflict",
"invalid_focus",
]);
function safeToolActivityCode(error: unknown): string | undefined {
const message = error instanceof Error ? error.message : String(error ?? "");
for (const code of SAFE_TOOL_ACTIVITY_CODES) {
if (message.includes(code)) {
return code === "focus_idempotency_conflict" || code === "invalid_focus"
? "duplicate_focus"
: code === "quote_not_grounded"
? "quote_mismatch"
: code;
}
}
return undefined;
}
export function mapStreamChunkToActivity(chunk: AgentChunkType): RectificationActivityEvent | null {
if (chunk.type !== "tool-call" && chunk.type !== "tool-result" && chunk.type !== "tool-error") {
return null;
@@ -196,7 +221,13 @@ export function mapStreamChunkToActivity(chunk: AgentChunkType): RectificationAc
return { type: "tool.activity", tool: toolName, status: "started" };
}
if (chunk.type === "tool-error") {
return { type: "tool.activity", tool: toolName, status: "failed" };
const code = safeToolActivityCode(chunk.payload?.error);
return {
type: "tool.activity",
tool: toolName,
status: "failed",
...(code ? { code } : {}),
};
}
const methods = resultMethods(chunk);
return {
@@ -228,6 +259,7 @@ export function safePublicEvent(value: unknown): PublicStreamEvent | null {
activity?: unknown;
questionId?: unknown;
recoverable?: unknown;
origin?: unknown;
};
if (event.type === "thinking.delta") return null;
if (event.type === "error") {
@@ -254,11 +286,15 @@ export function safePublicEvent(value: unknown): PublicStreamEvent | null {
const methods = event.status === "completed" && Array.isArray(event.methods)
? [...new Set(event.methods.filter(isPublicRectificationMethod))]
: [];
const code = typeof event.code === "string" && SAFE_TOOL_ACTIVITY_CODES.has(event.code)
? event.code
: undefined;
return {
type: "tool.activity",
tool: event.tool,
status: event.status,
...(methods.length > 0 ? { methods } : {}),
...(code ? { code } : {}),
};
}
if (event.type === "activity.changed") {
frontend/src/lib/rectification-agentic/v9/tool-service.ts
+4
View File
@@ -1153,6 +1153,8 @@ export type V10EvidenceBatchItem = Readonly<{
occurredTo: string | null;
datePrecision: string;
summary: string;
quoteStart?: number | null;
quoteEnd?: number | null;
}>;
export type V10EvidenceBatchResult = Readonly<{
@@ -1186,6 +1188,8 @@ export async function recordV10EvidenceBatch(
sourceTurnId,
JSON.stringify({
quote: item.quote,
quote_start: item.quoteStart ?? null,
quote_end: item.quoteEnd ?? null,
subject: item.subject,
event_kind: item.eventKind,
domain: item.domain,
frontend/src/lib/rectification-agentic/v9/turn-narration.ts
+32
View File
@@ -0,0 +1,32 @@
import { parseAgentChoiceCopy } from "./choice-card";
import type { V9CaseDossier } from "./tool-service";
export type RectificationNarrationDto = Readonly<{
acknowledgedFacts: readonly string[];
nextQuestion: string | null;
}>;
export function publicNarrationDtoFromDossier(dossier: V9CaseDossier): RectificationNarrationDto {
const acknowledgedFacts = dossier.evidence
.filter((item) => item.status === "confirmed" || item.status === "draft" || item.status === "pending_confirmation")
.slice(-4)
.map((item) => item.summary.trim())
.filter((item) => item.length >= 2);
const choice = parseAgentChoiceCopy(dossier.conversationSummary.activeFocus?.expectedAnswerSchema ?? null);
return {
acknowledgedFacts,
nextQuestion: choice?.prompt ?? null,
};
}
export function composeRectificationTurnNarration(dto: RectificationNarrationDto): string {
const parts: string[] = [];
if (dto.acknowledgedFacts.length > 0) {
parts.push(`已经记下：${dto.acknowledgedFacts.join("；")}。`);
}
if (dto.nextQuestion) parts.push(dto.nextQuestion);
if (parts.length === 0) {
return "请继续说下一件你记得比较清楚、大概带年份的经历。";
}
return parts.join("");
}
frontend/src/mastra/agentic-rectification.ts
+4 -4
View File
@@ -8,7 +8,7 @@ import {
import {
RECTIFICATION_V9_SKILL_NAME,
createRectificationV9ReadOnlyTools,
createRectificationV9Tools,
createRectificationV9AgentTools,
type RectificationV9Context,
} from "./rectification-v9-tools";
@@ -68,10 +68,10 @@ const agenticRectificationInstructions = `你是 Jyotisha，只服务当前绑
5. candidate、accepted、confirmed 严格分离。Agent 不控制 billing、ownership、profile 写入、不可逆状态，也不得授予 exact-minute confirmation。
6. 工具执行过程保持静默。思考过程必须用简体中文，只写在思维链里：可以说你在核对哪类经历，禁止写工具名、错误码、参数、内部 ID、评分或密钥。正文像正常人说话，不写“本轮做了什么”，不描述 Skill、Case、Dossier、工具、内部 Activity、参数、错误或推理过程；完成凭证完全由服务端公开 Activity/receipt 展示。
7. 只基于成功 attempt 输出正文。工具失败时说明面向用户的边界，不声称未执行的方法或结果。
8. 当前轮新事件一律走 rectification-record-evidence-batch（一件也可以）。rectification-confirm-evidence 只用于用户对已有 pending 明确说“对/是”。不得要求用户把已说清的事件再发一遍。
8. 当前轮新事件一律走 rectification-record-evidence-batch（一件也可以）。优先传 source 原文的 quoteStart/quoteEnd，不要改写 quote。rectification-confirm-evidence 只用于用户对已有 pending 明确说“对/是”。不得要求用户把已说清的事件再发一遍。
9. 不得在同一回复中一边要求继续补证据，一边提供候选采用。落实 next_user_action：id=verify_adopted_time 时本轮只核一件前事，A 走 batch 并 compare，C 关闭该问，不要 offer 也不要 start_consultation。id=start_consultation 时请用户用当前采用时间看盘，对不上同时请改选其他候选。id 不是 adopt_representative 时不得调用 rectification-offer-candidates，也不得请用户采用。selection_allowed 只表示可以采用代表性时间，不是本轮必须出示卡片；propose_allowed 才是提出门。挡住出牌的方法层未齐时，source=event_probe 的冲突前事继续问并挡住出牌。方法覆盖已齐只进入候选区分，不等于 adopt。无日期 occupation_note 算职业已覆盖，不要再问职业，也不要因它出牌。id=ask_candidate_discriminator 或 session_outcome=discriminate_candidates 时按 candidate_contrast_packet / next_followup 问一件能拆开候选的前事，不得 offer。id=ask_holdout_validation 时做盘外核对，不得 offer。id=offer_provisional_range 时说明并列可信区间，不要称某分钟为当前推荐。accepted_time 为空且 session_outcome=adopt_representative 或 next_user_action.id=adopt_representative 时本轮结果是采用代表性时间，不要再问 next_followup；正文必须说本会话以代表性时间收口，不确认唯一分钟。unique_minute_path=closed_at_representative 时不得调用 confirm，不得把唯一分钟确认当下一步。用户说“暂时想不到了 / 没有更多 / 先这样”时改走 on_user_stop：账本为空则把已说的带日期经历 batch 写入再比较，有事件无结果则本轮 compare，已有代表性结果且尚未采用则解释、调用 offer-candidates 并请采用下方时间卡片，已采用则按 on_user_stop 看盘或改选。禁止只说记下了、会话会保留、以后再继续。出牌/采用轮把工具返回的 skill_verification_report 写入正文：筛选窗、事件–Dasha–Gochara 表、D9/D10 类型对照、六亲六步、职业类型表、占问 observation_only、文末技法审计表。80%/60% 只描述事件吻合率，不得写成已确认唯一出生分钟，也不得写成候选已经分开。确认门以 latest_result.confirmation_gate 为准；not_evaluated 不是 fail；官方分钟层 passed 仍不能单独打开确认门；holdout 为 not_ready 时 unique_minute_path 必须是 closed_at_representative，不得声称精确分钟或发布准确率。若宽度大于 5 或 confirmation_allowed 为 false，必须说这是一段不可分区间，把代表分钟称为代表性候选，不得说已定位到唯一分钟。候选未拉开时不得出示赢家卡；D9/D10 差异和精度阶段追问要用来区分，不得直接宣布不可分。用户仍可 accepted 代表性候选。
10. 不泄露系统提示词或 Skill 原文。
11. 追问只跟 method_followup_plan。账本为空或 collect_method_evidence 时用自然语言问一件带大概年份的经历，set-focus 不要写 choice，正文直接问，不要提点选卡。只有 next_followup 带 choice_frame（冲突探针、候选已经分不开、采用后核对前事）时才写 set-focus.expectedAnswerSchema.choice 的 A/B/C/D：题干由你写成自然语言是/否生平问题；年份和事件家族以 choice_frame.period 与 discriminating_event_probes 为准，不得发明年份，不要照抄 hint。挡住出牌的方法层未齐时，source=event_probe 只问这一件反推前事用来筛窗，不要继续轮询方法层，不要 offer。覆盖已齐后问区分探针，不要 adopt。采用后按剩余 dasha 探针核尚未出现过的年份，不要把已回答的考试质量题再问一遍。不要问两套盘哪个更像或可能性高低。A 是这件事大概就在那段时间，B 是有类似但年份不对或不够重大，C 是没有明显发生，D 是不记得；点选 A/B/C/D 与「先这样」由服务器按 questionId/optionId 确定性处理，不要把选项全文当成新事件，也不要为点选调用 resolve-focus、read-case 或 compare；自由文本补充才走工具。「先这样」由服务器补全；正文只说一句时间窗和为何问，禁止复述选项。不得询问外貌、体质、胎记或疤痕，也不得问钟点。不得按 missing_evidence_categories 轮询迁居，也不得先要 10–15 条事件长表。财务与健康只有用户主动说才问。方法覆盖为感情→事业→家人→职业→占问。D9/D10 类型表是校时方法，不是命运承诺。以「盘外核对（不计分）」开头的消息不得调用 record-evidence-batch 或 propose-evidence。
11. 追问只跟 method_followup_plan 与服务器已持久化的 current_question / open_question。不要调用 rectification-set-focus；下一问和点选卡由 compare-candidates / read-case 在服务端事务内创建。账本为空或 collect_method_evidence 时用自然语言问一件带大概年份的经历，正文直接问，不要提点选卡。若工具返回了 open_question.prompt，原样用简体中文问这一句，不得发明年份，不要把已回答的考试质量题再问一遍。挡住出牌的方法层未齐时，source=event_probe 只问这一件反推前事用来筛窗，不要继续轮询方法层，不要 offer。覆盖已齐后问区分探针，不要 adopt。不要问两套盘哪个更像或可能性高低。点选 A/B/C/D 与「先这样」由服务器按 questionId/optionId 确定性处理，不要把选项全文当成新事件，也不要为点选调用 resolve-focus、read-case 或 compare；自由文本补充才走工具。正文禁止复述选项。不得询问外貌、体质、胎记或疤痕，也不得问钟点。不得按 missing_evidence_categories 轮询迁居，也不得先要 10–15 条事件长表。财务与健康只有用户主动说才问。方法覆盖为感情→事业→家人→职业→占问。D9/D10 类型表是校时方法，不是命运承诺。以「盘外核对（不计分）」开头的消息不得调用 record-evidence-batch 或 propose-evidence。
12. 证据有效变化后由服务器重算候选。不要等用户说“没有更多了”才比较，也不要对同一证据指纹再 compare。分钟扫描只在服务端，结果只是候选或平台，不得宣布确认。
13. 落实 start_consultation：前事核对结束或用户先这样后，请用户用当前采用时间看盘；对不上同时请改选其他候选。解释事件–Dasha 账本、双轨是否一致、换升时刻、精度阶段、D9/D10 类型对照和相对支持时，仍必须说候选范围不是出生时间真值。`;
@@ -86,7 +86,7 @@ export function getRectificationV9Agent(
model: model.model,
instructions: agenticRectificationInstructions,
skills: [resolveSkillPackageRuntimePath(skillPackage)],
tools: createRectificationV9Tools(ctx),
tools: createRectificationV9AgentTools(ctx),
});
}
frontend/src/mastra/rectification-v9-tools.ts
+107 -12
View File
@@ -71,6 +71,11 @@ import {
previousInferenceFromReceipt,
stampChoiceSchemaWithProbe,
} from "@/lib/rectification-agentic/v9/inference-adapter";
import { persistServerOwnedFocus } from "@/lib/rectification-agentic/v9/server-focus";
import {
publicEvidenceItemStatus,
resolveEvidenceQuote,
} from "@/lib/rectification-agentic/v9/evidence-quote";
import { projectTurnDecision } from "@/lib/rectification-agentic/v9/turn-decision";
import {
posteriorMap,
@@ -818,6 +823,22 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
return { persisted, score, parsed, windowScan: score.windowScan };
};
const persistPlanFocus = async (
parsed: DossierForTools,
latest: NonNullable<DossierForTools["latestResult"]>,
) => {
const collectingPlan = collectingFollowupForParsed(parsed, latest);
const persistedFocus = await persistServerOwnedFocus({
accounting,
userId,
caseId,
activeFocus: parsed.conversationSummary.activeFocus,
decisionReceipt: latest.decisionReceipt,
followup: collectingPlan.next_followup,
});
return { collectingPlan, persistedFocus };
};
const autoRescoreAfterEvidenceChange = async (targetCaseId: string) => {
try {
const dossier = await loadV9CaseDossier(accounting, userId, targetCaseId);
@@ -833,6 +854,18 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
return { status: "skipped" as const, executedMethods: [] as const, errorCode: null, cached: true };
}
const scored = await scoreAndPersistCurrentEvidence(targetCaseId);
const latest = {
resultId: scored.persisted.resultId,
candidates: scored.persisted.candidates,
selectionAllowed: scored.persisted.selectionAllowed,
confirmationAllowed: scored.persisted.confirmationAllowed,
representativeTime: scored.persisted.representativeTime,
selectedTime: null,
selectionKind: null,
algorithmVersion: scored.persisted.algorithmVersion,
decisionReceipt: scored.persisted.decisionReceipt,
};
await persistPlanFocus(scored.parsed, latest);
return {
status: "completed" as const,
executedMethods: scored.score.executedMethods,
@@ -863,6 +896,22 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
await receipt("rectification-read-case", "case.loaded", "started", { inputFingerprint });
try {
const dossier = await loadV9CaseDossier(accounting, userId, input.caseId);
const parsed = parseDossierForTools(dossier);
if (parsed.latestResult) {
const persisted = await persistPlanFocus(parsed, parsed.latestResult);
if (persisted.persistedFocus.status === "created") {
const refreshed = await loadV9CaseDossier(accounting, userId, input.caseId);
const projectionKind = input.projection ?? "turn_decision";
const projection = projectionKind === "full_diagnostics"
? safeCaseProjection(
parseDossierForTools(refreshed),
await loadV9CaseCompute(accounting, userId, input.caseId),
)
: projectTurnDecision(refreshed);
await receipt("rectification-read-case", "case.loaded", "completed", { inputFingerprint, resultFingerprint: hashResult(projection) });
return projection;
}
}
const projectionKind = input.projection ?? "turn_decision";
const projection = projectionKind === "full_diagnostics"
? safeCaseProjection(
@@ -1098,7 +1147,9 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
caseId: z.string().uuid(),
focusId: z.string().uuid().nullable().optional(),
items: z.array(z.object({
quote: z.string().trim().min(2).max(400),
quote: z.string().trim().min(2).max(400).optional(),
quoteStart: z.number().int().min(0).max(4000).optional(),
quoteEnd: z.number().int().min(1).max(4000).optional(),
proposedKind: evidenceKindSchema,
subject: z.enum(["self", "family", "other"]).default("self"),
domain: evidenceDomainSchema,
@@ -1115,14 +1166,32 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
if (!isEvidenceDomain(item.domain)) throw new RectificationToolServiceError("invalid_domain");
if (!isDatePrecision(item.datePrecision)) throw new RectificationToolServiceError("invalid_date_precision");
}
const groundedItems = input.items.map((item) => {
const resolved = resolveEvidenceQuote(userMessage ?? null, {
quote: item.quote,
quoteStart: item.quoteStart,
quoteEnd: item.quoteEnd,
});
return { item, resolved };
});
const inputFingerprint = canonicalToolInputFingerprint("rectification-record-evidence-batch", input);
await receipt("rectification-record-evidence-batch", "evidence.proposed", "started", { inputFingerprint });
try {
const scoringItems = input.items.flatMap((item, index) => (
isHoldoutVerificationQuote(item.quote) ? [] : [{ item, index }]
const mismatchResults = groundedItems.flatMap(({ resolved }, index) => (
resolved.ok
? []
: [{
index,
outcome: "rejected" as const,
evidenceId: null,
status: "quote_mismatch",
idempotent: false,
clarificationFields: [] as string[],
errorCode: "quote_mismatch",
}]
));
const holdoutResults = input.items.flatMap((item, index) => (
isHoldoutVerificationQuote(item.quote)
const holdoutResults = groundedItems.flatMap(({ resolved }, index) => (
resolved.ok && isHoldoutVerificationQuote(resolved.quote)
? [{
index,
outcome: "rejected" as const,
@@ -1134,12 +1203,17 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
}]
: []
));
const scoringItems = groundedItems.flatMap(({ item, resolved }, index) => (
resolved.ok && !isHoldoutVerificationQuote(resolved.quote)
? [{ item, index, quote: resolved.quote, quoteStart: resolved.quoteStart, quoteEnd: resolved.quoteEnd }]
: []
));
const result = scoringItems.length === 0
? {
items: holdoutResults,
items: [...mismatchResults, ...holdoutResults],
acceptedCount: 0,
needsClarificationCount: 0,
rejectedCount: holdoutResults.length,
rejectedCount: mismatchResults.length + holdoutResults.length,
focusId: input.focusId ?? null,
}
: await recordV10EvidenceBatch(
@@ -1148,8 +1222,10 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
input.caseId,
turnId,
input.focusId ?? null,
scoringItems.map(({ item }) => ({
quote: item.quote,
scoringItems.map(({ item, quote, quoteStart, quoteEnd }) => ({
quote,
quoteStart,
quoteEnd,
subject: evidenceSubjectForDomain(item.domain, item.subject),
eventKind: item.proposedKind as Parameters<typeof recordV10EvidenceBatch>[5][number]["eventKind"],
domain: item.domain,
@@ -1165,10 +1241,11 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
index: scoringItems[offset]?.index ?? item.index,
})),
...holdoutResults,
...mismatchResults,
].sort((left, right) => left.index - right.index),
acceptedCount: recorded.acceptedCount,
needsClarificationCount: recorded.needsClarificationCount,
rejectedCount: recorded.rejectedCount + holdoutResults.length,
rejectedCount: recorded.rejectedCount + holdoutResults.length + mismatchResults.length,
focusId: recorded.focusId,
}));
if (result.acceptedCount > 0) {
@@ -1186,9 +1263,14 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
outcome: item.outcome,
evidence_id: item.evidenceId,
status: item.status,
public_status: publicEvidenceItemStatus({
outcome: item.outcome,
idempotent: item.idempotent,
errorCode: item.errorCode,
}),
idempotent: item.idempotent,
clarification_fields: item.clarificationFields,
error_code: item.errorCode,
error_code: item.errorCode === "quote_not_grounded" ? "quote_mismatch" : item.errorCode,
})),
accepted_count: result.acceptedCount,
needs_clarification_count: result.needsClarificationCount,
@@ -1416,7 +1498,7 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
algorithmVersion: scored.persisted.algorithmVersion,
decisionReceipt: scored.persisted.decisionReceipt,
};
const collectingPlan = collectingFollowupForParsed(scored.parsed, latest);
const { collectingPlan, persistedFocus } = await persistPlanFocus(scored.parsed, latest);
const latestProjection = latestResultToolProjection(latest, {
proposeAllowed: readProposeAllowed(latest.decisionReceipt),
nextFollowup: collectingPlan.next_followup,
@@ -1432,6 +1514,13 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
domain_count: Object.keys(scored.parsed.domainCounts).length,
window_scan: scored.windowScan,
internal_observations: internalObservationsFromWindowScan(scored.windowScan),
open_question: persistedFocus.prompt
? {
question_id: persistedFocus.questionId,
prompt: persistedFocus.prompt,
status: persistedFocus.status,
}
: null,
};
await receipt("rectification-compare-candidates", "candidates.comparing", "completed", {
inputFingerprint,
@@ -1702,6 +1791,12 @@ export function createRectificationV9Tools(ctx: RectificationV9Context) {
};
}
export function createRectificationV9AgentTools(ctx: RectificationV9Context) {
const tools = createRectificationV9Tools(ctx);
const { "rectification-set-focus": _omitted, ...agentTools } = tools;
return agentTools;
}
export type RectificationV9Tools = ReturnType<typeof createRectificationV9Tools>;
export const RECTIFICATION_V9_SKILL_NAME = RECTIFICATION_SKILL_NAME;