fix(core): route local identity lookups through planner

Author: NubsCarson

packages/core/src/__tests__/message-runtime-stage1.test.ts

@@ -411,6 +411,120 @@ describe("runV5MessageRuntimeStage1", () => {
 		}
 	});
 
+	it("routes short chat-entity identity lookups through recall instead of simple guessing", async () => {
+		const runtime = makeRuntime([
+			JSON.stringify({
+				processMessage: "RESPOND",
+				plan: {
+					contexts: ["simple"],
+					reply: "Queuebot is just the same assistant you've seen before.",
+					simple: true,
+					requiresTool: false,
+				},
+				extract: {
+					facts: [],
+					relationships: [],
+					addressedTo: [],
+				},
+			}),
+			JSON.stringify({
+				thought: "Identity lookup should be grounded in recalled chat context.",
+				toolCalls: [],
+				messageToUser:
+					"I don't have enough recalled chat context to identify queuebot.",
+			}),
+		]);
+		runtime.actions = [
+			{
+				name: "MESSAGE",
+				contexts: ["messaging", "memory"],
+				description: "Search and inspect stored conversation messages.",
+				validate: async () => true,
+				handler: async () => ({ success: true }),
+			},
+		] as never;
+		runtime.composeState = vi.fn(async () => ({
+			values: { availableContexts: "simple, general, memory, messaging" },
+			data: {
+				providers: {
+					RECENT_MESSAGES: {
+						text: "# Conversation Messages\nrecent provider text",
+						providerName: "RECENT_MESSAGES",
+					},
+				},
+			},
+			text: "",
+		})) as never;
+
+		const result = await runV5MessageRuntimeStage1({
+			runtime,
+			message: makeMessage({
+				text: [
+					"[Recent channel context]",
+					"e2e: queuebot came up earlier in the channel.",
+					"",
+					"[Discord #general | NUBot test server] @e2e (Sat 05/23/2026 10:25 UTC): assistant (@1490833425802854491) who is queuebot?",
+				].join("\n"),
+				source: "discord",
+			}),
+			state: {
+				values: { availableContexts: "simple, general, memory, messaging" },
+				data: {},
+				text: "",
+			},
+			responseId: "00000000-0000-0000-0000-000000000005" as UUID,
+		});
+
+		expect(result.kind).toBe("planned_reply");
+		const plannerCall = useModelCalls(runtime)[1]?.[1] as {
+			messages?: Array<{ role?: string; content?: string | null }>;
+		};
+		const plannerUserContent = plannerCall.messages?.[1]?.content ?? "";
+		expect(plannerUserContent).toContain("identity_lookup_policy");
+		expect(plannerUserContent).toContain('"candidateActions":["MESSAGE"]');
+		expect(plannerUserContent).toContain("routing through recall context");
+		expect(plannerUserContent).not.toContain(
+			"Queuebot is just the same assistant",
+		);
+		if (result.kind === "planned_reply") {
+			expect(result.result.responseContent?.text).toBe(
+				"I don't have enough recalled chat context to identify queuebot.",
+			);
+		}
+	});
+
+	it("does not reroute ordinary public identity questions through recall", async () => {
+		const runtime = makeRuntime([
+			stage1Response({
+				contexts: ["simple"],
+				replyText: "Barack Obama is a former U.S. president.",
+				extra: { requiresTool: false },
+			}),
+		]);
+
+		const result = await runV5MessageRuntimeStage1({
+			runtime,
+			message: makeMessage({
+				text: "assistant (@1490833425802854491) who is obama?",
+				source: "discord",
+			}),
+			state: {
+				values: { availableContexts: "simple, general, memory, messaging" },
+				data: {},
+				text: "",
+			},
+			responseId: "00000000-0000-0000-0000-000000000005" as UUID,
+		});
+
+		expect(result.kind).toBe("direct_reply");
+		if (result.kind === "direct_reply") {
+			expect(result.result.responseContent?.text).toBe(
+				"Barack Obama is a former U.S. president.",
+			);
+		}
+		expect(useModelCalls(runtime)).toHaveLength(1);
+	});
+
 	it("does not treat the agent's own attachment ack as a user follow-up anchor", async () => {
 		const runtime = makeRuntime([
 			stage1Response({

packages/core/src/services/message.ts

@@ -2724,6 +2724,44 @@ const BUILTIN_RESPONSE_HANDLER_EVALUATORS: readonly ResponseHandlerEvaluator[] =
 				],
 			}),
 		},
+		{
+			name: "core.contextual_identity_lookup_requires_recall",
+			description:
+				"Routes short chat-entity identity lookups through memory/messaging instead of letting Stage 1 guess from the simple shortcut.",
+			priority: 20,
+			shouldRun: ({ message, messageHandler }) =>
+				!isSubAgentCompletionArtifact(message) &&
+				isSimpleMessageHandlerShortcut(messageHandler) &&
+				extractContextualIdentityLookupSubject(
+					getUserMessageText(message) ?? "",
+				) !== null,
+			evaluate: ({ runtime, message }) => {
+				const subject = extractContextualIdentityLookupSubject(
+					getUserMessageText(message) ?? "",
+				);
+				const messageAction = findRuntimeActionByNames(runtime, ["MESSAGE"]);
+				return {
+					setContexts: ["general", "memory", "messaging"],
+					...(messageAction
+						? {
+								addCandidateActions: [messageAction.name],
+							}
+						: {}),
+					clearReply: true,
+					addContextSlices: [
+						[
+							"identity_lookup_policy:",
+							`The current user is asking who/what "${subject ?? "the named subject"}" is in context.`,
+							"Ground the answer in recent messages, memory, or message-search results before identifying the subject.",
+							"If recalled context does not identify a chat-local subject, say that plainly instead of inventing a relationship; only use public knowledge when the subject is clearly a public entity.",
+						].join("\n"),
+					],
+					debug: [
+						`short identity lookup for "${subject ?? "unknown"}"; routing through recall context before answering`,
+					],
+				};
+			},
+		},
 	];
 
 /**
@@ -3490,6 +3528,122 @@ function looksLikeCompleteDirectReply(replyText: string): boolean {
 	);
 }
 
+function isSimpleMessageHandlerShortcut(
+	messageHandler: MessageHandlerResult,
+): boolean {
+	if (messageHandler.processMessage !== "RESPOND") return false;
+	if (messageHandler.plan.requiresTool === true) return false;
+	const contexts = messageHandler.plan.contexts ?? [];
+	const nonSimpleContexts = contexts.filter(
+		(context) => context !== SIMPLE_CONTEXT_ID,
+	);
+	return (
+		nonSimpleContexts.length === 0 &&
+		(messageHandler.plan.candidateActions?.length ?? 0) === 0
+	);
+}
+
+const CONTEXTUAL_IDENTITY_LOOKUP_PREFIXES = [
+	"who is ",
+	"who are ",
+	"who was ",
+	"who were ",
+	"who's ",
+	"whos ",
+	"what is ",
+	"what was ",
+	"what's ",
+	"whats ",
+	"tell me about ",
+	"do you know ",
+	"do you remember ",
+	"what do you know about ",
+] as const;
+
+const CONTEXTUAL_IDENTITY_PRONOUN_SUBJECTS = new Set([
+	"he",
+	"her",
+	"him",
+	"i",
+	"it",
+	"me",
+	"she",
+	"that",
+	"them",
+	"they",
+	"this",
+	"us",
+	"we",
+	"you",
+]);
+
+function removeLeadingPlatformAddress(text: string): string {
+	let cleaned = text
+		.replace(/<@!?\d+>/gu, " ")
+		.replace(/\s+/gu, " ")
+		.trim();
+	const displayAddressRe = /(?:^|[\s:])[^:\n]{0,96}\(@\d+\)\s+/gu;
+	let displayAddressEnd = -1;
+	for (
+		let displayAddressMatch = displayAddressRe.exec(cleaned);
+		displayAddressMatch !== null;
+		displayAddressMatch = displayAddressRe.exec(cleaned)
+	) {
+		displayAddressEnd = displayAddressRe.lastIndex;
+	}
+	if (displayAddressEnd > 0) {
+		cleaned = cleaned.slice(displayAddressEnd).trim();
+	}
+	return cleaned;
+}
+
+function cleanContextualLookupSubject(subject: string): string {
+	return subject
+		.replace(/[\s?.!]+$/gu, "")
+		.replace(/^["'`“”‘’]+|["'`“”‘’]+$/gu, "")
+		.replace(
+			/\s+(?:in|from|on)\s+(?:this\s+)?(?:chat|channel|thread|server)$/iu,
+			"",
+		)
+		.trim();
+}
+
+function isShortContextualLookupSubject(subject: string): boolean {
+	const normalized = subject.toLowerCase();
+	if (!normalized || CONTEXTUAL_IDENTITY_PRONOUN_SUBJECTS.has(normalized)) {
+		return false;
+	}
+	const words = normalized.split(/\s+/u).filter(Boolean);
+	if (words.length === 0 || words.length > 3) return false;
+	if (subject.length > 48) return false;
+	if (/^[0-9\s.,:+*/=()-]+$/u.test(subject)) return false;
+	const looksLikeLocalName =
+		/[@_\-0-9]/u.test(subject) ||
+		/\b(?:bot|agent|ai)\b/iu.test(subject) ||
+		/^[a-z][a-z0-9_-]{6,}$/u.test(subject);
+	return looksLikeLocalName;
+}
+
+function lastNonEmptyLine(text: string): string {
+	const lines = text.replace(/\r\n/g, "\n").split("\n");
+	for (let index = lines.length - 1; index >= 0; index -= 1) {
+		const line = lines[index]?.trim();
+		if (line) return line;
+	}
+	return text.trim();
+}
+
+function extractContextualIdentityLookupSubject(text: string): string | null {
+	const cleaned = removeLeadingPlatformAddress(lastNonEmptyLine(text));
+	const lower = cleaned.toLowerCase();
+	for (const prefix of CONTEXTUAL_IDENTITY_LOOKUP_PREFIXES) {
+		if (!lower.startsWith(prefix)) continue;
+		const subject = cleanContextualLookupSubject(cleaned.slice(prefix.length));
+		return isShortContextualLookupSubject(subject) ? subject : null;
+	}
+	return null;
+}
+
 function shouldPreferCompleteDirectReply(args: {
 	replyText: string;
 	currentMessageText: string;
@@ -5168,11 +5322,17 @@ export async function runV5MessageRuntimeStage1(args: {
 			preselectedActions: exposedPlannerActions,
 			actionSurface,
 		});
+		const responseHandlerContextSlices = stringArrayProperty(
+			(messageHandler.plan as { contextSlices?: unknown }).contextSlices,
+		);
 		const plannerContextWithDecision = appendContextEvent(plannerContext, {
 			id: `message-handler:${messageHandlerEndedAt}`,
 			type: "message_handler",
 			source: "message-service",
 			createdAt: messageHandlerEndedAt,
+			...(responseHandlerContextSlices.length > 0
+				? { content: responseHandlerContextSlices.join("\n\n") }
+				: {}),
 			metadata: {
 				processMessage: messageHandler.processMessage,
 				plan: {
@@ -5182,6 +5342,9 @@ export async function runV5MessageRuntimeStage1(args: {
 						: {}),
 					candidateActions: getMessageHandlerCandidateActions(messageHandler),
 					parentActionHints: getMessageHandlerParentActionHints(messageHandler),
+					...(responseHandlerContextSlices.length > 0
+						? { contextSlices: responseHandlerContextSlices }
+						: {}),
 					...(messageHandler.plan.reply !== undefined
 						? { reply: messageHandler.plan.reply }
 						: {}),