@iowarp/clio-coder 0.4.3 → 0.4.5

package/src/interactive/chat-loop.ts

@@ -13,6 +13,7 @@
  * machine, and the shared ChatTurnState the modules coordinate through.
  */
 
+import { AsyncLocalStorage } from "node:async_hooks";
 import { BusChannels, type RunAbortSource } from "../core/bus-events.js";
 import type { ClioSettings } from "../core/config.js";
 import type { SafeEventBus } from "../core/event-bus.js";
@@ -45,14 +46,21 @@ import {
 } from "../domains/providers/index.js";
 import { type AutonomyLevel, modelMayActivateSkills } from "../domains/safety/autonomy.js";
 import type { ProtectedArtifactState } from "../domains/safety/protected-artifacts.js";
-import type { CompactResult } from "../domains/session/compaction/compact.js";
+import type { CompactInput, CompactResult } from "../domains/session/compaction/compact.js";
 import type { ContextSnapshot, ContextUsageSnapshot } from "../domains/session/context-accounting.js";
 import { ceilChars, snapshotInputTokens } from "../domains/session/context-accounting.js";
 import type { ContextLedger } from "../domains/session/context-ledger.js";
 import type { SessionContract } from "../domains/session/contract.js";
-import type { CompactionTrigger, SessionEntry } from "../domains/session/entries.js";
+import {
+	type CompactionTrigger,
+	latestSkillContextState,
+	mainSkillContextState,
+	type SessionEntry,
+	SKILL_CONTEXT_STATE,
+} from "../domains/session/entries.js";
 import { protectedArtifactStateFromSessionEntries } from "../domains/session/protected-artifacts.js";
 import { isRetryableErrorMessage, type RetrySettings } from "../domains/session/retry.js";
+import { filterEntriesToActivePath } from "../domains/session/tree/active-path.js";
 import { createEngineAgent } from "../engine/agent.js";
 import { resolveReservedOutputTokens } from "../engine/apis/output-budget.js";
 import { cwdHash } from "../engine/session.js";
@@ -65,6 +73,7 @@ import {
 	createPendingSkillToolPolicy,
 	detectOverflowFromState,
 	detectTerminalFailureFromState,
+	explainInterruptedAssistant,
 	notConfiguredNotice,
 	noticeMessage,
 	pendingSkillRequestPreamble,
@@ -189,6 +198,8 @@ export type ChatLoopEvent =
 	| ToolApprovalStateEvent;
 
 export interface ChatSubmitOptions {
+	/** Host-owned run identity, scoped to this submit and its internal continuations. */
+	hostRun?: ToolInvokeOptions["hostRun"];
 	images?: ReadonlyArray<ImageContent>;
 	/** Files already expanded into this session's working context. */
 	workingContextPaths?: ReadonlyArray<string>;
@@ -443,7 +454,11 @@ export interface CreateChatLoopDeps {
 	 * Both sites share an AutoCompactionTrigger so two fires in the same tick
 	 * coalesce onto one summarization call.
 	 */
-	autoCompact?: (instructions?: string, trigger?: CompactionTrigger) => Promise<CompactResult | null>;
+	autoCompact?: (
+		instructions?: string,
+		trigger?: CompactionTrigger,
+		budget?: Pick<CompactInput, "keepRecentTokens" | "preserveUserTurnId" | "skillContextState" | "signal">,
+	) => Promise<CompactResult | null>;
 	/** Optional observability sink for orchestrator chat token usage. */
 	observability?: ObservabilityContract;
 	/**
@@ -649,10 +664,33 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	 * line back when it lifts; the skill-activation ledger entry already
 	 * records provenance, so this is the notice, not a second UI.
 	 */
-	const armSkillSurface = (policy: PendingSkillToolPolicy | undefined, loadedBefore?: ReadonlySet<string>): void => {
+	const armSkillSurface = (
+		policy: PendingSkillToolPolicy | undefined,
+		loadedBefore?: ReadonlySet<string>,
+		explicitOff = false,
+	): void => {
 		const previous = skillSurfaceNames(state.activeSkillSurface).join(", ");
 		const next = armedSkillSurface(policy);
 		const current = skillSurfaceNames(next).join(", ");
+		if (
+			deps.session?.current() &&
+			(explicitOff ||
+				previous.length > 0 ||
+				(policy?.loadedSkillNames.size ?? 0) > 0 ||
+				(policy?.requests.length ?? 0) > 0)
+		) {
+			const entries = filterEntriesToActivePath(deps.readSessionEntries?.() ?? [], state.lastTurnId ?? undefined);
+			const selection = next
+				? mainSkillContextState(entries, next)
+				: (policy?.loadedSkillNames.size ?? 0) > 0
+					? null
+					: { version: 1 as const, activationRefs: [] };
+			const data = selection ?? { version: 1 as const, activationRefs: [], unknown: true as const };
+			if (JSON.stringify(data) !== JSON.stringify(latestSkillContextState(entries))) {
+				// Persist before changing live state: restart must not resurrect a cleared/replaced skill.
+				deps.session.appendEntry({ kind: "custom", customType: SKILL_CONTEXT_STATE, parentTurnId: state.lastTurnId, data });
+			}
+		}
 		state.activeSkillSurface = next;
 		const activated = skillSurfaceLabels(policy).filter((label) => !loadedBefore?.has(label.split(" ")[0] ?? label));
 		if (activated.length > 0) {
@@ -692,10 +730,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 	const retrySettings = (): RetrySettings => normalizeRetrySettings(deps.getSettings().chat.retry);
 
+	const hostRunContext = new AsyncLocalStorage<ToolInvokeOptions["hostRun"]>();
 	const currentToolInvokeOptions = (): Partial<ToolInvokeOptions> => {
 		const options: Partial<ToolInvokeOptions> = {
 			toolResultMaxBytes: deps.getSettings().context.toolResultMaxBytes,
 		};
+		const hostRun = hostRunContext.getStore();
+		if (hostRun !== undefined) options.hostRun = hostRun;
 		const sessionId = deps.session?.current()?.id ?? null;
 		if (sessionId) options.sessionId = sessionId;
 		const turnId = state.activeUserTurnId ?? state.lastTurnId;
@@ -774,7 +815,10 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		emitNotice,
 	});
 	const emitRuntimeEvent = (event: AgentEvent | AssistantDeltaEvent): void => {
-		if (event.type === "message_end") rewriteStallAbortMessage(state, event.message);
+		if (event.type === "message_end") {
+			rewriteStallAbortMessage(state, event.message);
+			explainInterruptedAssistant(event.message, state.activeInterruptReason);
+		}
 		emit(event as ChatLoopEvent);
 	};
 
@@ -1007,7 +1051,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 		interruptRefusal: () => (state.streaming ? interruptRefusalReason() : null),
 		clearSkillSurface: () => {
 			const cleared = skillSurfaceNames(state.activeSkillSurface);
-			armSkillSurface(undefined);
+			armSkillSurface(undefined, undefined, true);
 			return cleared;
 		},
 		clearQueuedFollowUps: () => queues.clearQueuedMirror().map((entry) => entry.text),
@@ -1145,9 +1189,10 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			const forceNow = process.env.CLIO_CODER_FORCE_COMPACT === "1";
 			try {
 				setTurnPreparation("compacting");
-				await context.runAutoCompact(agentRuntime, forceNow, undefined, undefined, submittedText);
+				await context.runAutoCompact(agentRuntime, forceNow, undefined, undefined, submittedText, pendingSkillPolicy);
 			} catch (err) {
 				emitNotice(`[Clio Coder] auto-compaction failed: ${err instanceof Error ? err.message : String(err)}`);
+				if (err instanceof Error && err.name === "AbortError") return;
 			} finally {
 				endPreparationCompaction();
 			}
@@ -1170,8 +1215,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 					toolSignature,
 				});
 
-			const reservedOutput = resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions.maxTokens);
 			const effectiveWindow = agentRuntime.runtimeResolution.contextWindowDetails.effectiveContextWindow;
+			const outputForInput = (inputTokens: number): number =>
+				resolveReservedOutputTokens(agentRuntime.runtimeResolution.capabilityDecisions.maxTokens, {
+					api: agentRuntime.agent.state.model?.api ?? "",
+					contextWindow: effectiveWindow,
+					inputTokens,
+				});
 			const pendingInputTokens = ceilChars(submittedText.length);
 			let turnSnapshot = captureTurnSnapshot("pending");
 			// The snapshot prices the prompt at chars/4. When the provider has
@@ -1184,28 +1234,38 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 					snapshotInputTokens(snapshot) + pendingInputTokens,
 					context.liveContextEstimate(agentRuntime, submittedText).tokens,
 				);
-			const totalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
+			const inputEstimate = budgetedPromptTokens(turnSnapshot);
+			const reservedOutput = outputForInput(inputEstimate);
+			const totalEstimate = inputEstimate + reservedOutput;
 
 			if (effectiveWindow > 0 && totalEstimate > effectiveWindow) {
 				emitNotice(
 					`[Clio Coder] Estimated request size ${totalEstimate} tokens (input ${totalEstimate - reservedOutput} + output budget ${reservedOutput}) exceeds the effective context window of ${effectiveWindow} tokens. Running compaction before sending...`,
 				);
 				setTurnPreparation("compacting");
+				let compactionFailure: string | undefined;
 				const compacted = await context
-					.runAutoCompact(agentRuntime, true, undefined, undefined, submittedText)
+					.runAutoCompact(agentRuntime, true, undefined, "overflow", submittedText, pendingSkillPolicy)
+					.catch((error: unknown) => {
+						compactionFailure = error instanceof Error ? error.message : String(error);
+						return false;
+					})
 					.finally(endPreparationCompaction);
 				if (!compacted) {
-					emitNotice(
-						"[Clio Coder] Compaction could not reclaim enough space. Request blocked; trim the prompt, reduce active tools, or start a fresh session.",
+					emitAdmissionNotice(
+						`[Clio Coder] Request exceeds the context window and compaction could not reclaim enough space.${compactionFailure ? ` ${compactionFailure}.` : ""} Trim the prompt or reduce active tools.`,
+						"context-window-exceeded",
 					);
 					return;
 				}
 				context.refreshAgentMessagesFromSession(agentRuntime);
 				turnSnapshot = captureTurnSnapshot("pending");
-				const postTotalEstimate = budgetedPromptTokens(turnSnapshot) + reservedOutput;
+				const postInputEstimate = budgetedPromptTokens(turnSnapshot);
+				const postTotalEstimate = postInputEstimate + outputForInput(postInputEstimate);
 				if (postTotalEstimate > effectiveWindow) {
-					emitNotice(
+					emitAdmissionNotice(
 						`[Clio Coder] Request still exceeds the effective window after compaction (${postTotalEstimate} > ${effectiveWindow}). Request blocked.`,
+						"context-window-exceeded",
 					);
 					return;
 				}
@@ -1264,6 +1324,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			state.toolProseAbortReason = null;
 			state.toolProseAssessedChars = 0;
 			state.activeInterruptReason = null;
+			state.interruptedAssistantMessage = null;
 			state.interruptedUsage = null;
 
 			// 6. Cache-disturbance honesty (T3.3)
@@ -1355,19 +1416,21 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				}
 				state.streaming = false;
 				if (state.activeInterruptReason !== null) {
-					// The loop-guard cancel showed its closing message live; persist
-					// the durable closing turn only now, after the aborted run's
-					// in-flight tool results have all landed, so the ledger replays
-					// as tool_calls → tool_results → closing text.
-					// A thinking-only abort never reaches the ledger, so its estimated
-					// spend rides on the closing turn; persistence computes nothing
-					// further for a message that already reports positive usage.
-					const closing = noticeMessage(state.activeInterruptReason);
-					if (state.interruptedUsage !== null) {
-						(closing as { usage?: unknown }).usage = state.interruptedUsage;
-					}
-					persistence.appendAssistantTurn(closing);
+					const reason = state.activeInterruptReason;
 					state.activeInterruptReason = null;
+					// A partial response already closed with the cancellation reason.
+					// Only a hollow abort needs a synthetic assistant, after all tool
+					// results have landed. Publish its notice after settlement too, so
+					// it cannot split the entry the provider's message_end finalizes.
+					if (state.interruptedAssistantMessage === null) {
+						const closing = noticeMessage(reason);
+						if (state.interruptedUsage !== null) {
+							(closing as { usage?: unknown }).usage = state.interruptedUsage;
+						}
+						persistence.appendAssistantTurn(closing);
+						emitNotice(reason, "warning", "turn.interrupted");
+					}
+					state.interruptedAssistantMessage = null;
 					state.interruptedUsage = null;
 				}
 				state.currentPendingSkillPolicy = priorPendingSkillPolicy;
@@ -1385,6 +1448,7 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 
 		cancel(options?: ChatCancelOptions): void {
 			const wasStreaming = state.streaming;
+			context.cancelCompaction();
 			recovery.cancelRetryCountdown();
 			// Clear both queues before the abort settles the in-flight prompt:
 			// a cancelled run must not deliver queued steers or follow-ups, and
@@ -1392,19 +1456,13 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 			queues.clearQueuedMirror();
 			const requestedReason = options?.reason?.trim();
 			if (wasStreaming) {
-				// Show the stop reason immediately, but persist the durable closing
-				// turn only when the run settles (submit's finally). The abort below
-				// still lets the in-flight tool results land; persisting here would
-				// interleave an assistant turn between a tool-call message and its
-				// results, which strict chat templates reject on replay.
-				// `activeInterruptReason` meanwhile suppresses the empty aborted
-				// messages the abort leaves behind, in both the ledger and the live
-				// transcript. Operator cancels take the same path with the default
-				// text, so they no longer render a redundant "[aborted] Request was
-				// aborted" turn on top of the cancellation notice.
+				// Keep immediate feedback in the footer. A transcript notice here
+				// would split the streamed entry before message_end can finalize it.
+				// The reason is carried by the provider's aborted assistant, or by
+				// one synthetic closing record after an empty abort settles.
 				state.activeInterruptReason =
 					requestedReason && requestedReason.length > 0 ? requestedReason : "[Clio Coder] active response cancelled.";
-				emitNotice(state.activeInterruptReason, "warning", "turn.interrupted");
+				emitFooterNotice("warning", state.activeInterruptReason, "turn.interrupted");
 			}
 			state.runtime?.agent.abort();
 			if (wasStreaming && deps.bus) {
@@ -1595,11 +1653,16 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				return;
 			}
 			let compacted = false;
+			enterPreparation();
+			setTurnPreparation("compacting");
 			try {
 				compacted = await context.runAutoCompact(agentRuntime, true, instructions, "force");
 			} catch (err) {
 				emitNotice(`[/context compact] ${err instanceof Error ? err.message : String(err)}`);
 				return;
+			} finally {
+				leavePreparation();
+				endPreparationCompaction();
 			}
 			if (!compacted) {
 				emitNotice("[/context compact] nothing to compact; session is empty or no cut crossed");
@@ -1633,6 +1696,9 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 	// released at admission, not settlement, so steering stays immediate.
 	let admissionTail: Promise<void> | null = null;
 	api.submit = (text, options = {}) => {
+		// Capture before admission can await. Internal resubmits inherit the
+		// async scope; every independent public submit explicitly starts its own.
+		const hostRun = options.hostRun === undefined ? undefined : structuredClone(options.hostRun);
 		// The operator owns the slot from the keystroke, not from admission. The
 		// prefix the pre-warm already pushed through stays in it either way, so
 		// aborting here costs nothing and stops the real turn from queueing behind
@@ -1669,14 +1735,18 @@ export function createChatLoop(deps: CreateChatLoopDeps): ChatLoop {
 				// A presentation observer cannot refuse a turn after the editor has
 				// consumed it. The ordinary render path can recover on its next tick.
 			}
-			return submitTracked(text, {
-				...submitOptions,
-				onAdmitted: () => {
-					releaseTicket();
-					leaveOnce();
-					options.onAdmitted?.();
-				},
-			}).finally(releaseTicket);
+			return hostRunContext
+				.run(hostRun, () =>
+					submitTracked(text, {
+						...submitOptions,
+						onAdmitted: () => {
+							releaseTicket();
+							leaveOnce();
+							options.onAdmitted?.();
+						},
+					}),
+				)
+				.finally(releaseTicket);
 		};
 		const run = previous ? previous.then(start) : start();
 		return run.finally(leaveOnce);

package/src/interactive/chat-renderer.ts

@@ -17,6 +17,7 @@ import { existsSync } from "node:fs";
 import { ToolNames } from "../core/tool-names.js";
 import { foldWorkingSet } from "../domains/context/working-set/fold.js";
 import { compactionCut } from "../domains/context/working-set/visible.js";
+import { captureSkillContext } from "../domains/session/compaction/compact.js";
 import type {
 	BashExecutionEntry,
 	BranchSummaryEntry,
@@ -25,12 +26,14 @@ import type {
 	FileEntryEntry,
 	MessageEntry,
 	ModelChangeEntry,
+	PreservedSkillContext,
 	ProtectedArtifactEntry,
 	SessionEntry,
 	SessionInfoEntry,
 	ThinkingLevelChangeEntry,
 	WorkerRunEntry,
 } from "../domains/session/entries.js";
+import { latestSkillContextState, verifiedSkillContextCheckpoint } from "../domains/session/entries.js";
 import {
 	HANDOFF_NOTE_CUSTOM_TYPE,
 	HANDOFF_SEED_CUSTOM_TYPE,
@@ -334,6 +337,8 @@ export function createCoalescingChatRenderer(deps: CreateCoalescingChatRendererD
  * Options for the rehydrate helper used by /resume and /fork.
  */
 export interface RehydrateChatPanelOptions {
+	/** Unprojected ledger for verifying historical skill receipts after eviction projection. */
+	skillContextEntries?: ReadonlyArray<SessionEntry>;
 	/**
 	 * Select the active branch ancestry without truncating later sidecars.
 	 * Live compaction replay uses this so a summary appended after the current
@@ -451,6 +456,7 @@ function richMessageFromEntry(entry: MessageEntry, maxTextChars?: number): Agent
 			"responseModelIdObservation",
 			"responseModel",
 			"responseId",
+			"providerThinkingLevel",
 			"gatewayRouting",
 			"diagnostics",
 			"contextUsageInvalidated",
@@ -1068,6 +1074,15 @@ function appendContextMessage(
 	out.push(makeTextMessage(role, truncateReplayText(trimmed), timestamp));
 }
 
+const UNVERIFIED_SKILL_CHECKPOINT_TEXT =
+	"Preserved skill instructions on this checkpoint failed integrity verification and were not replayed. If a skill still applies, ask the operator to run /skill <name> again.";
+
+/** Selected but unverifiable: name the skill and the exact ledger ref instead of dropping it. */
+function unverifiedSkillContextText(skill: PreservedSkillContext): string {
+	const activation = skill.activation;
+	return `Preserved skill instructions for ${activation.name} (source=${activation.source} hash=${activation.hash} path=${activation.filePath}) could not be re-verified against this session's ledger and were not replayed. If the skill still applies, recall the original load with context(scope="recall", ref="${skill.resultRef}") or ask the operator to run /skill ${activation.name} again.`;
+}
+
 function skillActivationContextText(entry: Extract<SessionEntry, { kind: "skillActivation" }>): string {
 	const activation = entry.activation;
 	const turn = activation.turnId ? ` turn=${activation.turnId}` : "";
@@ -1080,6 +1095,16 @@ export function buildReplayAgentMessagesFromTurns(
 ): AgentMessage[] {
 	const out = createOrderedReplaySink();
 	const seenToolCalls = new Set<string>();
+	const activeEntries = truncateAtTurn(
+		filterEntriesToActivePath(turns, options.activeLeafTurnId ?? options.uptoTurnId),
+		options.uptoTurnId,
+	);
+	const skillState = latestSkillContextState(activeEntries);
+	const evidence = truncateAtTurn(
+		filterEntriesToActivePath(options.skillContextEntries ?? turns, options.activeLeafTurnId ?? options.uptoTurnId),
+		options.uptoTurnId,
+	);
+	const verified = captureSkillContext(evidence, skillState);
 	for (const entry of selectReplayEntries(turns, options)) {
 		switch (entry.kind) {
 			case "message": {
@@ -1113,8 +1138,43 @@ export function buildReplayAgentMessagesFromTurns(
 				break;
 			case "compactionSummary":
 				appendContextMessage(out, "user", compactionContextText(entry), entry.timestamp);
+				if (entry.userContext)
+					out.push(
+						makeTextMessage("user", `Active user instructions (verbatim):\n${entry.userContext.text}`, entry.timestamp),
+					);
+				if (entry.skillContext !== undefined) {
+					const retainedSkills = entry.skillContext.skills.length;
+					if (!verifiedSkillContextCheckpoint(entry.skillContext)) {
+						// The raw pairs behind a tampered checkpoint are already outside the
+						// replay window. Say so rather than dropping the skill without a trace.
+						if (retainedSkills > 0) {
+							out.push(makeTextMessage("user", UNVERIFIED_SKILL_CHECKPOINT_TEXT, entry.timestamp));
+						}
+						break;
+					}
+					for (const skill of entry.skillContext.skills) {
+						// An explicit later state that no longer names this activation is a
+						// deliberate off or replacement; it leaves no trace, by design.
+						if (skillState && !skillState.unknown && !skillState.activationRefs.includes(skill.activationRef)) continue;
+						const receipt = verified?.skills.find((candidate) => candidate.activationRef === skill.activationRef);
+						if (!receipt || JSON.stringify(receipt) !== JSON.stringify(skill)) {
+							// Still selected, but its original receipt cannot be re-verified
+							// (masked, rewritten, or unknown state). Never inject unverified
+							// bytes, and never lose the skill silently either.
+							out.push(makeTextMessage("user", unverifiedSkillContextText(skill), entry.timestamp));
+							continue;
+						}
+						// This is historical instruction context, not a generated summary or a tool result.
+						// Keep the exact captured blocks outside summary replay's text cap.
+						out.push(makeTextMessage("user", `Preserved skill request (verbatim):\n${skill.requestText}`, entry.timestamp));
+						out.push(makeTextMessage("user", `Verified loaded skill: ${JSON.stringify(skill.activation)}`, entry.timestamp));
+						for (const block of skill.content) out.push(makeTextMessage("user", block.text, entry.timestamp));
+					}
+				}
 				break;
 			case "skillActivation":
+				if (entry.activation.runId !== undefined || (skillState && !skillState.activationRefs.includes(entry.turnId)))
+					break;
 				appendContextMessage(out, "user", skillActivationContextText(entry), entry.timestamp);
 				break;
 			// The one custom entry that becomes a model message. `/handoff` seeds a

package/src/interactive/context-recall-command.ts

@@ -65,6 +65,7 @@ function headlineFor(ref: string, tokens: number, state: EvictedState | undefine
 	if (state !== undefined) {
 		parts.push(state.by === undefined ? `evicted: ${state.reason}` : `evicted: ${state.reason} by ${state.by}`);
 	}
+	if (state === undefined) parts.push("summarized");
 	parts.push(`${formatTokens(tokens)} tokens`);
 	if (offloadPath !== undefined) parts.push(`offload: ${offloadPath}`);
 	return `[/context recall] ${parts.join(" · ")}`;
@@ -85,7 +86,7 @@ export function runOperatorRecall(ref: string, deps: OperatorRecallDeps): Operat
 	// A ref that resolves to nothing is usually a typo or a stale marker; the
 	// shared message ends with the refs the operator could have typed instead.
 	if (!resolved.ok)
-		return { ok: false, message: `[/context recall] ${recallErrorMessage(resolved.error, entries, view)}` };
+		return { ok: false, message: `[/context recall] ${recallErrorMessage(resolved.error, entries, view, leaf)}` };
 	const { result } = resolved;
 	const fields = buildRecallFields(result, { trigger: "operator" });
 	try {