@cortexkit/opencode-magic-context 0.46.1 → 0.47.0

package/src/config/live-run-config.ts

@@ -11,6 +11,14 @@ export function sampleLiveConfig<T extends MagicContextConfig>(boot: T, fresh: T
         const parts = path.split(".");
         let value: unknown = fresh;
         for (const part of parts) value = (value as Record<string, unknown> | undefined)?.[part];
+        if (value === undefined) {
+            // An unset live path must not create its parent objects. An empty `omp`
+            // block, for example, shadows the `pi` block it would otherwise fall back
+            // to, and the historian and dreamer lose their configured model. Only
+            // clear a leaf the boot config actually has, so removing a key live works.
+            removeLeaf(result, parts);
+            continue;
+        }
         let target = result;
         for (const part of parts.slice(0, -1)) {
             const child = target[part];
@@ -27,6 +35,26 @@ export function sampleLiveConfig<T extends MagicContextConfig>(boot: T, fresh: T
     return result as T;
 }
 
+function removeLeaf(root: Record<string, unknown>, parts: string[]): void {
+    const parents = parts.slice(0, -1);
+    let node: Record<string, unknown> = root;
+    for (const part of parents) {
+        const child = node[part];
+        if (!child || typeof child !== "object" || Array.isArray(child)) return;
+        node = child as Record<string, unknown>;
+    }
+    const leaf = parts.at(-1);
+    if (leaf === undefined || !Object.hasOwn(node, leaf)) return;
+    // Copy the parent chain before deleting so the boot config object is never mutated.
+    let target = root;
+    for (const part of parents) {
+        const copy = { ...(target[part] as Record<string, unknown>) };
+        target[part] = copy;
+        target = copy;
+    }
+    delete target[leaf];
+}
+
 export function changedLiveKeys(previous: MagicContextConfig, next: MagicContextConfig): string[] {
     const at = (config: MagicContextConfig, path: string): unknown =>
         path

package/src/config/migrate-config-location.ts

@@ -278,7 +278,7 @@ function sortJson(value: unknown): unknown {
     if (value && typeof value === "object") {
         const sorted: Record<string, unknown> = {};
         for (const key of Object.keys(value as Record<string, unknown>).sort()) {
-            if (key === "protected_tags") continue;
+            if (key === "protected_tags" || key === "clear_reasoning_age") continue;
             sorted[key] = sortJson((value as Record<string, unknown>)[key]);
         }
         return sorted;
@@ -509,7 +509,9 @@ export function migrateConfigFile(opts: ConfigFileMigrationOptions): ConfigFileM
         let migratedContent = first.content;
         let strippedProtectedTags = false;
         try {
-            const stripped = removeJsoncValue(first.content, ["protected_tags"]);
+            const stripped = removeJsoncValue(removeJsoncValue(first.content, ["protected_tags"]), [
+                "clear_reasoning_age",
+            ]);
             if (stripped !== first.content) {
                 migratedContent = stripped;
                 strippedProtectedTags = true;
@@ -520,7 +522,12 @@ export function migrateConfigFile(opts: ConfigFileMigrationOptions): ConfigFileM
 
         atomicWriteConfigFile(opts.targetPath, migratedContent);
         if (strippedProtectedTags) {
-            info?.(`Stripped deprecated "protected_tags" key during config location migration`);
+            if (first.content.includes('"protected_tags"'))
+                info?.(`Stripped deprecated "protected_tags" key during config location migration`);
+            if (first.content.includes('"clear_reasoning_age"'))
+                info?.(
+                    `Stripped deprecated "clear_reasoning_age" key during config location migration`,
+                );
         }
         info?.(
             `Migrated Magic Context ${opts.scope} config from ${first.path} to ${opts.targetPath}`,

package/src/config/schema/magic-context.test.ts

@@ -42,7 +42,6 @@ describe("MagicContextConfigSchema", () => {
                 cache_ttl: "5m",
                 prompt_surface: { default: "full" },
                 execute_threshold_percentage: 65,
-                clear_reasoning_age: 50,
                 history_budget_percentage: DEFAULT_HISTORY_BUDGET_PERCENTAGE,
                 historian_timeout_ms: DEFAULT_HISTORIAN_TIMEOUT_MS,
                 embedding: {
@@ -701,8 +700,10 @@ describe("MagicContextConfigSchema", () => {
             ).toBe(30000);
         });
 
-        it("rejects clear_reasoning_age below minimum", () => {
-            expect(() => MagicContextConfigSchema.parse({ clear_reasoning_age: 9 })).toThrow();
+        it("accepts deprecated clear_reasoning_age without applying its old validation", () => {
+            expect(
+                MagicContextConfigSchema.parse({ clear_reasoning_age: 9 }).keep_reasoning_tokens,
+            ).toBeUndefined();
         });
 
         it("rejects historian_timeout_ms below minimum", () => {

package/src/config/schema/magic-context.ts

@@ -682,7 +682,7 @@ export const HistorianConfigSchema = AgentMetadataSchema.extend({
         )
         .optional()
         .describe(
-            'Readable historian tool expansions, keyed by exact host tool name. Templates override built-in defaults; false disables an expansion. Supports ${input.path}, ${output.path}, bare ${output}, array [N], [*].field, .each("${field}"), .join("separator"), .count and final .truncate(N). Missing fields are empty; placeholders default to 300 characters, lists to 10 elements, expansions to 1000 characters. Valid in user and project config; affects historian/recomp and verbose ctx_expand only, never the wire or default ctx_expand transcript.',
+            'Readable historian tool expansions, keyed by exact host tool name. Templates override built-in defaults; false disables an expansion. Supports ${input.path}, ${output.path}, bare ${output}, array [N], [*].field, .each("${field}"), .join("separator"), .count and final .truncate(N). Missing fields are empty. Historian text and lists have no implicit caps; explicit .truncate(N) keeps complete sentences and marks omitted characters, or emits only the marker if no sentence fits. When the ctx_expand history-recovery tool is called in verbose mode, its tool-call previews retain their original built-in templates and limits (300 characters per placeholder, 10 list elements, 1000 characters per expansion). Valid in user and project config; never changes the wire or default ctx_expand transcript.',
         ),
     opencode: OpenCodeHarnessBlockSchema.optional(),
     pi: PiHarnessBlockSchema.optional(),
@@ -963,7 +963,8 @@ export interface MagicContextConfig {
     protected_tokens?: number;
     protected_tags?: number;
     protected_tools: Record<string, number>;
-    clear_reasoning_age: number;
+    clear_reasoning_age?: unknown;
+    keep_reasoning_tokens?: number | Record<string, number>;
     history_budget_percentage: number;
     historian_timeout_ms: number;
     commit_cluster_trigger: {
@@ -1263,10 +1264,21 @@ export const MagicContextConfigSchema = z
             )
             .meta({ deprecated: true }),
         clear_reasoning_age: z
-            .number()
-            .min(10)
-            .default(50)
-            .describe("Clear reasoning/thinking blocks older than N tags (default: 50)"),
+            .unknown()
+            .optional()
+            .describe("Deprecated and ignored. Use keep_reasoning_tokens instead.")
+            .meta({ deprecated: true }),
+        keep_reasoning_tokens: z
+            .union([
+                z.number().int().min(0).max(1_000_000),
+                z
+                    .object({ default: z.number().int().min(0).max(1_000_000).optional() })
+                    .catchall(z.number().int().min(0).max(1_000_000)),
+            ])
+            .optional()
+            .describe(
+                "Reasoning tokens to keep on rebuilding passes. Number or per-model object; exact, shorter model keys, provider/*, then default. Omitted: fixed 10,000. 0 removes all eligible historical reasoning; newest and exempt steps always stay.",
+            ),
         history_budget_percentage: z
             .number()
             .min(0.05)

package/src/shared/auto-search-lifecycle.ts

@@ -0,0 +1,27 @@
+const pending = new Map<string, Set<AbortController>>();
+
+/** Cleanup cancels optional searches and backfill, not durable served decisions. */
+export function registerAutoSearchWork(sessionId: string): {
+    signal: AbortSignal;
+    done: () => void;
+} {
+    const controller = new AbortController();
+    const work = pending.get(sessionId) ?? new Set<AbortController>();
+    pending.set(sessionId, work);
+    work.add(controller);
+    return {
+        signal: controller.signal,
+        done: () => {
+            work.delete(controller);
+            if (pending.get(sessionId) === work && work.size === 0) pending.delete(sessionId);
+        },
+    };
+}
+
+export function cancelAutoSearchWork(sessionId?: string): void {
+    for (const [id, work] of pending) {
+        if (sessionId !== undefined && id !== sessionId) continue;
+        pending.delete(id);
+        for (const controller of work) controller.abort();
+    }
+}

package/src/shared/historian-tool-defaults.json

@@ -3,11 +3,11 @@
   "ctx_memory": "Memory ${input.action} ${input.category} ${input.ids}: ${input.content} → ${output.truncate(160)}",
   "todowrite": "Todos (${input.todos.count}): ${input.todos.each(\"${status}: ${content}\")}",
   "question": "Asked user: ${input.questions[*].question.join(\" / \")} → ${output}",
-  "task": "Task ${input.subagent_type}: ${input.prompt} → ${output.truncate(200)}",
-  "ask": "Asked: ${input.question.truncate(250)} [options: ${input.options.join(\" / \")}] ${input.resolution} → ${output.truncate(300)}",
-  "peer_send": "PM to ${input.agent}${input.agent_id}: ${input.message.truncate(400)}",
-  "board": "Board ${input.verb}: ${input.ops.each(\"${op} ${item}${lane.title} ${state}${lane.status}${props.text} ${lane.items[*].text}\")}",
-  "room": "Room ${input.action} ${input.room_id}: ${input.text.truncate(400)}",
-  "work": "Work ${input.action} ${input.id}: ${input.prompt_file}${input.prompt.truncate(200)}${input.notes.truncate(200)} → ${output.truncate(160)}",
+  "task": "Task ${input.subagent_type}: ${input.prompt.truncate(600)} → ${output.truncate(200)}",
+  "ask": "Asked: ${input.question} [options: ${input.options.join(\" / \")}] ${input.text}${input.resolution} → ${output.truncate(300)}",
+  "peer_send": "PM ${input.recipient}: ${input.message}",
+  "board": "Board ${input.verb}${input.board_lane}: ${input.ops.each(\"${op} ${lane_label} ${item}${props.text}${lane.items} ${state}${props.state}${lane.status}${id}${title}\")}",
+  "room": "Room ${input.action} ${input.room_label}: ${input.room_detail}",
+  "work": "Work ${input.action} ${input.title}${input.id}: ${input.prompt.truncate(600)}${input.notes.truncate(600)} → ${output.truncate(160)}",
   "knowhow": "Looked up how-to: ${input.query}${input.id}"
 }

package/src/shared/historian-tool-expansions.ts

@@ -1,18 +1,75 @@
 import defaults from "./historian-tool-defaults.json";
+import previewDefaults from "./historian-tool-preview-defaults.json";
 import { renderToolTemplate, type ToolExpansionMap } from "./historian-tool-template";
 
 export { defaults as DEFAULT_TOOL_EXPANSIONS };
-export function expandToolPart(part: unknown, overrides?: ToolExpansionMap): string | null {
+
+// Room actions, private-message addresses and board lanes have multiple input
+// shapes. Derive readable labels only for built-ins; configured template overrides
+// keep the unmodified tool input.
+function builtinInput(tool: string, input: unknown): unknown {
+    if (!input || typeof input !== "object") return input;
+    const i = input as Record<string, unknown>;
+    if (tool === "peer_send") {
+        const external = i.external as Record<string, unknown> | undefined;
+        const recipient = i.reply_to_pmid
+            ? `reply to ${i.reply_to_pmid}`
+            : i.agent || i.agent_id
+              ? `to ${i.agent || i.agent_id}`
+              : external?.session_id || i.session_id
+                ? `to session ${external?.session_id || i.session_id}`
+                : "to unknown recipient";
+        return { ...i, recipient };
+    }
+    if (tool === "room") {
+        return {
+            ...i,
+            room_label: i.room_id || i.title,
+            room_detail:
+                i.action === "create" || i.action === "invite"
+                    ? `invitees: ${renderToolTemplate("${input.invitees}", i)}`
+                    : i.text,
+        };
+    }
+    if (tool === "board") {
+        return {
+            ...i,
+            board_lane: i.lane ? ` ${i.lane}` : "",
+            ops: Array.isArray(i.ops)
+                ? i.ops.map((op) =>
+                      op && typeof op === "object"
+                          ? {
+                                ...op,
+                                lane_label:
+                                    typeof op.lane === "string"
+                                        ? op.lane
+                                        : op.lane?.title || op.lane?.id,
+                            }
+                          : op,
+                  )
+                : i.ops,
+        };
+    }
+    return input;
+}
+
+export function expandToolPart(
+    part: unknown,
+    overrides?: ToolExpansionMap,
+    legacyPreview = false,
+): string | null {
     if (!part || typeof part !== "object") return null;
     const p = part as Record<string, unknown>;
     if (p.type !== "tool" || typeof p.tool !== "string") return null;
-    const template =
-        overrides && Object.hasOwn(overrides, p.tool)
-            ? overrides[p.tool]
-            : Object.hasOwn(defaults, p.tool)
-              ? defaults[p.tool as keyof typeof defaults]
-              : undefined;
+    const builtinDefaults = legacyPreview ? previewDefaults : defaults;
+    const overridden = overrides && Object.hasOwn(overrides, p.tool);
+    const template = overridden
+        ? overrides[p.tool]
+        : Object.hasOwn(builtinDefaults, p.tool)
+          ? builtinDefaults[p.tool as keyof typeof defaults]
+          : undefined;
     if (typeof template !== "string") return null;
     const state = p.state as Record<string, unknown> | undefined;
-    return renderToolTemplate(template, state?.input, state?.output ?? state?.error);
+    const input = overridden || legacyPreview ? state?.input : builtinInput(p.tool, state?.input);
+    return renderToolTemplate(template, input, state?.output ?? state?.error, legacyPreview);
 }

package/src/shared/historian-tool-preview-defaults.json

@@ -0,0 +1,13 @@
+{
+  "ctx_note": "Note ${input.action} ${input.note_ids}: ${input.content} → ${output.truncate(160)}",
+  "ctx_memory": "Memory ${input.action} ${input.category} ${input.ids}: ${input.content} → ${output.truncate(160)}",
+  "todowrite": "Todos (${input.todos.count}): ${input.todos.each(\"${status}: ${content}\")}",
+  "question": "Asked user: ${input.questions[*].question.join(\" / \")} → ${output}",
+  "task": "Task ${input.subagent_type}: ${input.prompt} → ${output.truncate(200)}",
+  "ask": "Asked: ${input.question.truncate(250)} [options: ${input.options.join(\" / \")}] ${input.resolution} → ${output.truncate(300)}",
+  "peer_send": "PM to ${input.agent}${input.agent_id}: ${input.message.truncate(400)}",
+  "board": "Board ${input.verb}: ${input.ops.each(\"${op} ${item}${lane.title} ${state}${lane.status}${props.text} ${lane.items[*].text}\")}",
+  "room": "Room ${input.action} ${input.room_id}: ${input.text.truncate(400)}",
+  "work": "Work ${input.action} ${input.id}: ${input.prompt_file}${input.prompt.truncate(200)}${input.notes.truncate(200)} → ${output.truncate(160)}",
+  "knowhow": "Looked up how-to: ${input.query}${input.id}"
+}

package/src/shared/historian-tool-template.ts

@@ -1,4 +1,4 @@
-/** A deliberately non-executable language for readable, bounded historian tool lines. */
+/** A deliberately non-executable language for readable historian tool lines. */
 export type ToolExpansionMap = Record<string, string | false>;
 type Step = { field: string } | { index: number } | { project: string };
 type Expression = {
@@ -6,7 +6,7 @@ type Expression = {
     each?: Template;
     join?: string;
     count?: boolean;
-    cap: number;
+    cap?: number;
 };
 type Template = Array<string | Expression>;
 
@@ -78,7 +78,7 @@ class Parser {
                 if (this.source[this.pos] === "(") return this.error();
             } else break;
         }
-        const expression: Expression = { steps, cap: 300 };
+        const expression: Expression = { steps };
         if (this.take(".each(")) {
             if (relative) return this.error();
             expression.each = parseTemplate(this.quoted(), true);
@@ -145,9 +145,24 @@ function compiled(source: string): Template | null {
 function oneLine(value: string): string {
     return value.replace(/[\r\n\u2028\u2029]+/g, " ");
 }
-function truncate(value: string, cap: number): string {
+function truncate(value: string, cap?: number, legacyPreview = false): string {
     const chars = Array.from(oneLine(value));
-    return chars.length > cap ? `${chars.slice(0, cap).join("")}…` : chars.join("");
+    if (cap === undefined || chars.length <= cap) return chars.join("");
+    if (legacyPreview) return `${chars.slice(0, cap).join("")}…`;
+    // Explicit caps stop after sentence-ending punctuation so a cut is not
+    // mistaken for an intact tool message. If no sentence fits, show only the marker.
+    let end = 0;
+    for (let i = 0; i < Math.min(cap, chars.length); i++) {
+        if (!".!?。！？".includes(chars[i])) continue;
+        let next = i + 1;
+        while (next < chars.length && "\"'”’)]".includes(chars[next])) next++;
+        if (
+            next <= cap &&
+            ("。！？".includes(chars[i]) || next === chars.length || /[ \t]/.test(chars[next]))
+        )
+            end = next;
+    }
+    return `${end ? `${chars.slice(0, end).join("")} ` : ""}[… ${chars.length - end} more characters]`;
 }
 function scalar(value: unknown): string {
     if (value === undefined) return "";
@@ -174,10 +189,11 @@ function field(value: unknown, key: string): unknown {
         ? (value as Record<string, unknown>)[key]
         : undefined;
 }
-function render(nodes: Template, root: unknown): string {
+function render(nodes: Template, root: unknown, legacyPreview: boolean): string {
     return nodes
         .map((node) => {
             if (typeof node === "string") return node;
+            const cap = node.cap ?? (legacyPreview ? 300 : undefined);
             let value = root;
             let list = false;
             for (const step of node.steps) {
@@ -196,18 +212,31 @@ function render(nodes: Template, root: unknown): string {
                 }
             }
             if (node.count)
-                return truncate(Array.isArray(value) ? String(value.length) : "", node.cap);
+                return truncate(
+                    Array.isArray(value) ? String(value.length) : "",
+                    cap,
+                    legacyPreview,
+                );
             if (node.each || list || node.join !== undefined) {
                 if (!Array.isArray(value)) return "";
                 const elements = value
-                    .slice(0, 10)
+                    .slice(0, legacyPreview ? 10 : undefined)
                     .map((item) =>
-                        truncate(node.each ? render(node.each, item) : scalar(item), 300),
+                        truncate(
+                            node.each ? render(node.each, item, legacyPreview) : scalar(item),
+                            legacyPreview ? 300 : undefined,
+                            legacyPreview,
+                        ),
                     );
-                if (value.length > 10) elements.push(`… +${value.length - 10} more`);
-                return truncate(elements.join(node.join ?? (node.each ? "; " : ", ")), node.cap);
+                if (legacyPreview && value.length > 10)
+                    elements.push(`… +${value.length - 10} more`);
+                return truncate(
+                    elements.join(node.join ?? (node.each ? "; " : ", ")),
+                    cap,
+                    legacyPreview,
+                );
             }
-            return truncate(scalar(value), node.cap);
+            return truncate(scalar(value), cap, legacyPreview);
         })
         .join("");
 }
@@ -216,6 +245,7 @@ export function renderToolTemplate(
     source: string,
     input: unknown,
     output?: unknown,
+    legacyPreview = false,
 ): string | null {
     const nodes = compiled(source);
     if (!nodes) return null;
@@ -241,8 +271,12 @@ export function renderToolTemplate(
         !node.each &&
         !node.count &&
         node.join === undefined
-            ? truncate(text ?? "", node.cap)
+            ? truncate(text ?? "", node.cap ?? (legacyPreview ? 300 : undefined), legacyPreview)
             : node,
     );
-    return truncate(render(bareOutputNodes, root), 1000);
+    return truncate(
+        render(bareOutputNodes, root, legacyPreview),
+        legacyPreview ? 1000 : undefined,
+        legacyPreview,
+    );
 }

package/src/shared/sqlite-640-review-r2.test.ts

@@ -0,0 +1,136 @@
+import { expect, spyOn, test } from "bun:test";
+import { openDatabase } from "../features/magic-context/storage-db";
+import { getOrCreateSessionMeta, updateSessionMeta } from "../features/magic-context/storage-meta";
+import { captureLkgSlot, replayLkg } from "../hooks/magic-context/lkg-replay";
+import { resetLkgSlotsForTest } from "../hooks/magic-context/lkg-slot";
+import type { RustLkgReplayParticipant } from "../hooks/magic-context/rust-lkg-freeze-registry";
+import type { MessageLike } from "../hooks/magic-context/transform-operations";
+import { createMessagesTransformHandler } from "../plugin/messages-transform";
+
+for (const change of ["content", "reorder", "interior deletion"] as const) {
+    test(`r2: OpenCode admission validates current ${change} after a backed-off wait`, async () => {
+        resetLkgSlotsForTest();
+        const db = openDatabase();
+        if (!db) throw new Error("throwaway database unavailable");
+        const sessionId = `r2-stale-${change}`;
+        getOrCreateSessionMeta(db, sessionId);
+        const model = { providerID: "openai", modelID: "gpt-4.1" };
+        const raw = ["u0", "u1", "u2"].map((id) => ({
+            info: { id, role: "user", sessionID: sessionId, model },
+            parts: [{ type: "text", text: id }],
+        })) as MessageLike[];
+        const saved = structuredClone(raw);
+        (saved[0].parts[0] as { text: string }).text = "§1§ saved managed prefix";
+        const capture = () =>
+            captureLkgSlot({
+                sessionId,
+                input: raw,
+                output: saved,
+                modelKey: "openai/gpt-4.1",
+                providerKey: "openai",
+            });
+        expect(capture()).toBe(true);
+        const output = { messages: structuredClone(raw) };
+        let fits = 0;
+        let callbacks = 0;
+        let changed: MessageLike[] | undefined;
+        const participant: RustLkgReplayParticipant = {
+            lastPassStamp: () => 1,
+            enterFreezeFromExternalServe: () => {},
+            emergencyFailClosed: () => false,
+            stripPersistedReasoning: () => {},
+            replayFits: () => ++fits > 1,
+        };
+        const exec = db.exec.bind(db);
+        let attempts = 0;
+        const spy = spyOn(db, "exec").mockImplementation((sql) => {
+            if (sql === "BEGIN IMMEDIATE" && ++attempts <= 2) {
+                if (attempts === 1)
+                    setImmediate(() => {
+                        if (change === "content")
+                            (output.messages[0].parts[0] as { text: string }).text =
+                                "history edited while waiting";
+                        else if (change === "reorder")
+                            [output.messages[0], output.messages[1]] = [
+                                output.messages[1],
+                                output.messages[0],
+                            ];
+                        else output.messages.splice(1, 1);
+                        changed = structuredClone(output.messages);
+                    });
+                throw Object.assign(new Error("writer busy"), { code: "SQLITE_BUSY" });
+            }
+            return exec(sql);
+        });
+        try {
+            const handler = createMessagesTransformHandler({
+                rustReplayParticipant: () => participant,
+                magicContext: {
+                    "experimental.chat.messages.transform": async () => {
+                        callbacks++;
+                    },
+                },
+            });
+            await handler({}, output as Parameters<typeof handler>[1]);
+            expect(changed).toBeDefined();
+            // A fresh validator rejects this exact input, independently of the wrapper's snapshot.
+            expect(capture()).toBe(true);
+            expect(
+                replayLkg({
+                    sessionId,
+                    messages: changed!,
+                    modelKey: "openai/gpt-4.1",
+                    providerKey: "openai",
+                }).ok,
+            ).toBe(false);
+            expect(callbacks).toBe(1);
+            expect(output.messages).toEqual(changed!);
+        } finally {
+            spy.mockRestore();
+            resetLkgSlotsForTest();
+        }
+    });
+}
+
+test("r2: writer callback runs once after three failed acquisitions with no saved request", async () => {
+    resetLkgSlotsForTest();
+    const db = openDatabase();
+    if (!db) throw new Error("throwaway database unavailable");
+    getOrCreateSessionMeta(db, "r2-three-busy");
+    updateSessionMeta(db, "r2-three-busy", { systemPromptTokens: 100 });
+    const exec = db.exec.bind(db);
+    let attempts = 0;
+    let callbacks = 0;
+    const spy = spyOn(db, "exec").mockImplementation((sql) => {
+        if (sql === "BEGIN IMMEDIATE" && ++attempts <= 3)
+            throw Object.assign(new Error("busy"), { code: "SQLITE_BUSY" });
+        return exec(sql);
+    });
+    try {
+        const handler = createMessagesTransformHandler({
+            magicContext: {
+                "experimental.chat.messages.transform": async () => {
+                    callbacks++;
+                },
+            },
+        });
+        const output = {
+            messages: [
+                {
+                    info: { id: "u", sessionID: "r2-three-busy", role: "user" },
+                    parts: [{ type: "text", text: "§1§ managed" }],
+                },
+            ],
+        };
+        const bytes = JSON.stringify(output);
+        await handler({}, output as Parameters<typeof handler>[1]);
+        expect({ attempts, callbacks, bytes: JSON.stringify(output) }).toEqual({
+            attempts: 4,
+            callbacks: 1,
+            bytes,
+        });
+    } finally {
+        spy.mockRestore();
+        resetLkgSlotsForTest();
+    }
+});