@cortexkit/opencode-magic-context 0.49.7 → 0.49.9

package/src/shared/hidden-zen-read.test.ts

@@ -0,0 +1,99 @@
+import { expect, test } from "bun:test";
+import {
+    needsBlockedRead,
+    rememberV1HiddenRun,
+    shapeV1HiddenMessage,
+    withBlockedReadInstruction,
+} from "./hidden-zen-read";
+
+for (const [agent, task, sentence] of [
+    [
+        "historian",
+        "initial",
+        "Summarize only the supplied conversation and memory context. Do not call tools.",
+    ],
+    [
+        "historian-recomp",
+        "repair",
+        "Summarize only the supplied conversation and memory context. Do not call tools.",
+    ],
+    [
+        "historian-editor",
+        "fallback",
+        "Summarize only the supplied conversation and memory context. Do not call tools.",
+    ],
+    [
+        "dreamer-classifier",
+        "classify-memories",
+        "Classify only the supplied memory context. Do not call tools.",
+    ],
+    [
+        "dreamer-classifier",
+        "compress-cues",
+        "Compress only the supplied memory cues. Do not call tools.",
+    ],
+    [
+        "smart-note-compiler",
+        "compile",
+        "Compile only the supplied conditions and memory context. Do not call tools.",
+    ],
+    [
+        "dreamer-reviewer",
+        "review-user-memories",
+        "Review only the supplied observations and memory context. Do not call tools.",
+    ],
+]) {
+    test(`Zen compatibility is provider-scoped and prompt-guided for ${agent}/${task}`, () => {
+        expect(needsBlockedRead(agent!, "opencode")).toBe(true);
+        for (const provider of ["anthropic", "openai", "opencode-zen", undefined])
+            expect(needsBlockedRead(agent!, provider)).toBe(false);
+        expect(
+            withBlockedReadInstruction("original prompt\n", { agent: agent!, metadata: { task } }),
+        ).toBe(`original prompt\n\n\n${sentence}`);
+        expect(withBlockedReadInstruction(sentence!, { agent: agent!, metadata: { task } })).toBe(
+            sentence!,
+        );
+    });
+}
+
+test("genuine-tool agents and user agents never receive the compatibility read", () => {
+    for (const agent of [
+        "dreamer",
+        "dreamer-docs",
+        "dreamer-memory-mapper",
+        "dreamer-primer-investigator",
+        "dreamer-retrospective",
+        "build",
+        "custom",
+    ])
+        expect(needsBlockedRead(agent, "opencode")).toBe(false);
+});
+
+test("v1 uses the host-resolved default model only on a registered hidden session", () => {
+    const message = { agent: "historian", model: { providerID: "opencode" }, system: "original" };
+    shapeV1HiddenMessage("user", message);
+    expect(message).toEqual({
+        agent: "historian",
+        model: { providerID: "opencode" },
+        system: "original",
+    });
+    rememberV1HiddenRun("child", {
+        agent: "historian",
+        kind: "historian",
+        system: "original",
+        title: "test",
+        directory: "/project",
+        timeoutMs: 1000,
+    });
+    try {
+        shapeV1HiddenMessage("child", message);
+        expect(message.agent).toBe("historian-zen-blocked-read");
+        expect(message.system).toBe(
+            "original\n\nSummarize only the supplied conversation and memory context. Do not call tools.",
+        );
+        shapeV1HiddenMessage("child", message);
+        expect(message.system.match(/Do not call tools\./g)).toHaveLength(1);
+    } finally {
+        rememberV1HiddenRun("child", undefined);
+    }
+});

package/src/shared/hidden-zen-read.ts

@@ -0,0 +1,88 @@
+import type { HiddenRunIdentity } from "../hooks/magic-context/compartment-runner-types";
+
+/** These agents transform supplied text; agents that inspect code or memories keep their existing tools. */
+export function isToolFreeHiddenAgent(agent: string): boolean {
+    return [
+        "historian",
+        "historian-recomp",
+        "historian-editor",
+        "dreamer-classifier",
+        "dreamer-reviewer",
+        "smart-note-compiler",
+    ].includes(agent);
+}
+
+export const TOOL_USE_DISABLED = "tool use is disabled for this task";
+export const ZEN_READ_AGENT_SUFFIX = "-zen-blocked-read";
+
+export function needsBlockedRead(agent: string, providerID: string | undefined): boolean {
+    return providerID === "opencode" && isToolFreeHiddenAgent(agent);
+}
+
+export function blockedReadInstruction(run: Pick<HiddenRunIdentity, "agent" | "metadata">): string {
+    if (run.agent.startsWith("historian"))
+        return "Summarize only the supplied conversation and memory context. Do not call tools.";
+    if (run.metadata?.task === "compress-cues")
+        return "Compress only the supplied memory cues. Do not call tools.";
+    if (run.agent === "smart-note-compiler")
+        return "Compile only the supplied conditions and memory context. Do not call tools.";
+    if (run.agent === "dreamer-reviewer")
+        return "Review only the supplied observations and memory context. Do not call tools.";
+    return "Classify only the supplied memory context. Do not call tools.";
+}
+
+export function withBlockedReadInstruction(
+    system: string,
+    run: Parameters<typeof blockedReadInstruction>[0],
+): string {
+    const instruction = blockedReadInstruction(run);
+    return system.endsWith(instruction) ? system : `${system}${system ? "\n\n" : ""}${instruction}`;
+}
+
+// Only sessions opened by Magic Context's hidden executor can have tool calls
+// blocked in OpenCode 1. Agent names and user permissions never select user sessions.
+const blockedSessions = new Set<string>();
+const v1Runs = new Map<string, HiddenRunIdentity>();
+
+export function rememberV1HiddenRun(sessionID: string, run: HiddenRunIdentity | undefined): void {
+    if (run) v1Runs.set(sessionID, run);
+    else {
+        v1Runs.delete(sessionID);
+        setBlockedReadSession(sessionID, false);
+    }
+}
+
+/**
+ * OpenCode 1 calls chat.message after selecting the request's actual model.
+ * Select the read-bearing carrier there so agent defaults and fallback models
+ * cannot accidentally apply Zen's compatibility surface to another provider.
+ */
+export function shapeV1HiddenMessage(
+    sessionID: string,
+    message: {
+        agent?: string;
+        model?: { providerID: string };
+        system?: string;
+    },
+): void {
+    const run = v1Runs.get(sessionID);
+    if (!run) return;
+    const agent = message.agent ?? run.agent;
+    const base = agent.endsWith(ZEN_READ_AGENT_SUFFIX)
+        ? agent.slice(0, -ZEN_READ_AGENT_SUFFIX.length)
+        : agent;
+    const enabled = needsBlockedRead(base, message.model?.providerID);
+    setBlockedReadSession(sessionID, enabled);
+    if (!enabled) return;
+    message.agent = `${base}${ZEN_READ_AGENT_SUFFIX}`;
+    message.system = withBlockedReadInstruction(message.system ?? "", run);
+}
+
+export function setBlockedReadSession(sessionID: string, enabled: boolean): void {
+    if (enabled) blockedSessions.add(sessionID);
+    else blockedSessions.delete(sessionID);
+}
+
+export function blockedReadSessionRefusal(sessionID: string): string | undefined {
+    return blockedSessions.has(sessionID) ? TOOL_USE_DISABLED : undefined;
+}

package/src/shared/history-owner.test.ts

@@ -0,0 +1,60 @@
+import { expect, test } from "bun:test";
+import { handoffHistoryWork } from "./history-owner";
+import type { MagicContextRpcClient } from "./rpc-client";
+
+test("moved-session recomp is handed to the current directory before local work starts", async () => {
+    const calls: unknown[] = [];
+    const result = await handoffHistoryWork({
+        storageDir: "/isolated/mc",
+        directory: "/old",
+        sessionId: "session",
+        method: "recomp",
+        params: { sessionId: "session" },
+        readDirectory: async () => "/new",
+        findOwner: async () =>
+            ({
+                call: async (...args: unknown[]) => {
+                    calls.push(args);
+                    return { ok: true };
+                },
+            }) as unknown as MagicContextRpcClient,
+    });
+    expect(result).toEqual({ ok: true });
+    expect(calls).toEqual([
+        ["recomp", { sessionId: "session", directory: "/new", historyHandoff: true }],
+    ]);
+});
+
+test("moved-session recovery explains how to load a missing owner and stops handoff loops", async () => {
+    for (const historyHandoff of [false, true]) {
+        const result = await handoffHistoryWork({
+            storageDir: "/isolated/mc",
+            directory: "/old",
+            sessionId: "session",
+            method: "wrapup",
+            params: { sessionId: "session", historyHandoff },
+            readDirectory: async () => "/new",
+            findOwner: async () => null,
+        });
+        expect(result?.ok).toBe(false);
+        expect(result?.error).toContain(
+            "Reopen this session in its current project directory (/new)",
+        );
+    }
+});
+
+test("history recovery remains local when the host still reports this directory", async () => {
+    expect(
+        await handoffHistoryWork({
+            storageDir: "/isolated/mc",
+            directory: "/project",
+            sessionId: "session",
+            method: "recomp",
+            params: {},
+            readDirectory: async () => "/project",
+            findOwner: async () => {
+                throw new Error("must not discover");
+            },
+        }),
+    ).toBeUndefined();
+});

package/src/shared/history-owner.ts

@@ -0,0 +1,43 @@
+import { sameProjectDirectory } from "./project-directory-key";
+import { MagicContextRpcClient } from "./rpc-client";
+
+/** History-compression children need the current project plugin's prompt and recognition of their run IDs. */
+export async function handoffHistoryWork(args: {
+    storageDir: string;
+    directory: string;
+    sessionId: string;
+    method: string;
+    params: Record<string, unknown>;
+    readDirectory: () => Promise<string | null>;
+    findOwner?: typeof MagicContextRpcClient.findSessionOwner;
+}): Promise<Record<string, unknown> | undefined> {
+    const current = await args.readDirectory();
+    if (current && sameProjectDirectory(current, args.directory)) return undefined;
+    const action = `Reopen this session in its current project directory${current ? ` (${current})` : ""}, then run /ctx-recomp.`;
+    if (!current || args.params.historyHandoff === true)
+        return {
+            ok: false,
+            error: `History recovery could not locate a stable owning instance. ${action}`,
+        };
+    const owner = await (args.findOwner ?? MagicContextRpcClient.findSessionOwner)(
+        args.storageDir,
+        args.sessionId,
+    );
+    if (!owner)
+        return {
+            ok: false,
+            error: `History recovery needs the instance for ${current}. ${action}`,
+        };
+    try {
+        return await owner.call(args.method, {
+            ...args.params,
+            directory: current,
+            historyHandoff: true,
+        });
+    } catch {
+        return {
+            ok: false,
+            error: `The owning instance could not accept history recovery. ${action}`,
+        };
+    }
+}

package/src/shared/host-stall-profiler-node.ts

@@ -224,7 +224,7 @@ export function createNodeHostStallProfiler(deps: NodeProfilerDeps): HostStallPr
             const api = await deps.createSession();
             if (stopped || !existsSync(enablePath)) return;
             session = api;
-            api.connect();
+            inRootAsyncContext(() => api.connect());
             await post(api, "Profiler.enable");
             await post(api, "Profiler.setSamplingInterval", {
                 interval: Math.round(options.sampleIntervalMs * 1000),
@@ -272,3 +272,5 @@ export function createNodeHostStallProfiler(deps: NodeProfilerDeps): HostStallPr
         isUnavailable: () => unavailable,
     };
 }
+
+import { inRootAsyncContext } from "./sqlite";

package/src/shared/host-stall-profiler.ts

@@ -29,7 +29,7 @@ export function startHostStallProfilerSwitch(): void {
             now: () => performance.now(),
             wallNow: () => Date.now(),
             setInterval: (callback, ms) => {
-                const handle = setInterval(callback, ms);
+                const handle = inRootAsyncContext(() => setInterval(callback, ms));
                 (handle as { unref?: () => void }).unref?.();
                 return handle;
             },
@@ -55,3 +55,5 @@ export function startHostStallProfilerSwitch(): void {
         log("[magic-context] host stall profiler: could not start the enable-file switch", error);
     }
 }
+
+import { inRootAsyncContext } from "./sqlite";

package/src/shared/off-thread-migration-clock.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import {
     __resetOffThreadMigrationClockForTests,
+    __setOffThreadMigrationClockForTests,
     beginOffThreadMigration,
     startBootDeadline,
 } from "./off-thread-migration-clock";
@@ -11,6 +12,49 @@ async function expiredWithin(promise: Promise<void>, ms: number): Promise<boolea
     return Promise.race([promise.then(() => true), sleep(ms).then(() => false)]);
 }
 
+function createFakeClock() {
+    let now = 0;
+    let nextTimerId = 0;
+    const timers = new Map<number, { at: number; callback: () => void }>();
+    let timerCountWaiter: { count: number; resolve: () => void } | undefined;
+
+    return {
+        now: () => now,
+        setTimeout: (callback: () => void, delayMs: number) => {
+            const id = ++nextTimerId;
+            timers.set(id, { at: now + Math.max(0, delayMs), callback });
+            if (timerCountWaiter?.count === timers.size) {
+                timerCountWaiter.resolve();
+                timerCountWaiter = undefined;
+            }
+            return () => {
+                timers.delete(id);
+            };
+        },
+        advanceBy: (ms: number) => {
+            now += ms;
+            while (true) {
+                const next = [...timers.entries()].sort(
+                    (left, right) => left[1].at - right[1].at,
+                )[0];
+                if (!next || next[1].at > now) return;
+                timers.delete(next[0]);
+                next[1].callback();
+            }
+        },
+        waitForTimerCount: (count: number) => {
+            if (timers.size === count) return Promise.resolve();
+            return new Promise<void>((resolve) => {
+                timerCountWaiter = { count, resolve };
+            });
+        },
+    };
+}
+
+async function isSettled(promise: Promise<void>): Promise<boolean> {
+    return Promise.race([promise.then(() => true), Promise.resolve(false)]);
+}
+
 describe("boot deadline that excludes off-thread migration time", () => {
     afterEach(() => __resetOffThreadMigrationClockForTests());
 
@@ -19,32 +63,58 @@ describe("boot deadline that excludes off-thread migration time", () => {
         expect(await expiredWithin(deadline.expired, 500)).toBe(true);
     });
 
-    test("does not expire while a migration runs, and resumes counting afterwards", async () => {
+    test("does not count migration time and resumes with only the pre-migration time spent", async () => {
+        const clock = createFakeClock();
+        __setOffThreadMigrationClockForTests(clock);
         let deferred = 0;
+        let signalDeferred!: () => void;
+        const wasDeferred = new Promise<void>((resolve) => {
+            signalDeferred = resolve;
+        });
         const deadline = startBootDeadline(40, () => {
             deferred += 1;
+            signalDeferred();
         });
+        clock.advanceBy(15);
         const end = beginOffThreadMigration();
-        expect(await expiredWithin(deadline.expired, 150)).toBe(false);
+        clock.advanceBy(25);
+        await wasDeferred;
         expect(deferred).toBe(1);
 
-        const endedAt = performance.now();
+        clock.advanceBy(1_000_000);
+        expect(await isSettled(deadline.expired)).toBe(false);
+
+        const nextTimer = clock.waitForTimerCount(1).then(() => "scheduled" as const);
         end();
+        expect(
+            await Promise.race([nextTimer, deadline.expired.then(() => "expired" as const)]),
+        ).toBe("scheduled");
+
+        clock.advanceBy(24);
+        expect(await isSettled(deadline.expired)).toBe(false);
+        clock.advanceBy(1);
         await deadline.expired;
-        // Only the few milliseconds before the migration began were counted, so
-        // nearly the whole 40ms budget is still left once it ends.
-        expect(performance.now() - endedAt).toBeGreaterThanOrEqual(25);
     });
 
     test("time between migrations still counts", async () => {
+        const clock = createFakeClock();
+        __setOffThreadMigrationClockForTests(clock);
         const deadline = startBootDeadline(60);
-        await sleep(40);
+        clock.advanceBy(40);
         const end = beginOffThreadMigration();
-        await sleep(80);
+        clock.advanceBy(80);
+        expect(await isSettled(deadline.expired)).toBe(false);
+
+        const nextTimer = clock.waitForTimerCount(1).then(() => "scheduled" as const);
         end();
-        const endedAt = performance.now();
+        expect(
+            await Promise.race([nextTimer, deadline.expired.then(() => "expired" as const)]),
+        ).toBe("scheduled");
+
+        clock.advanceBy(19);
+        expect(await isSettled(deadline.expired)).toBe(false);
+        clock.advanceBy(1);
         await deadline.expired;
-        expect(performance.now() - endedAt).toBeLessThan(45);
     });
 
     test("a cancelled deadline never expires", async () => {

package/src/shared/off-thread-migration-clock.ts

@@ -19,9 +19,26 @@ let activeSince = 0;
 let accumulatedMs = 0;
 let idleWaiters: Array<() => void> = [];
 
+interface TestClock {
+    now(): number;
+    setTimeout(callback: () => void, delayMs: number): () => void;
+}
+
+let testClock: TestClock | undefined;
+
+function now(): number {
+    return testClock?.now() ?? performance.now();
+}
+
+function scheduleTimeout(callback: () => void, delayMs: number): () => void {
+    if (testClock) return testClock.setTimeout(callback, delayMs);
+    const timer = setTimeout(callback, delayMs);
+    return () => clearTimeout(timer);
+}
+
 /** Total milliseconds any off-thread migration has been running, up to `now`. */
-export function offThreadMigrationMs(now = performance.now()): number {
-    return accumulatedMs + (activeMigrations > 0 ? Math.max(0, now - activeSince) : 0);
+export function offThreadMigrationMs(at = now()): number {
+    return accumulatedMs + (activeMigrations > 0 ? Math.max(0, at - activeSince) : 0);
 }
 
 export function isOffThreadMigrationRunning(): boolean {
@@ -33,7 +50,7 @@ export function isOffThreadMigrationRunning(): boolean {
  * end; calling it more than once has no further effect.
  */
 export function beginOffThreadMigration(): () => void {
-    if (activeMigrations === 0) activeSince = performance.now();
+    if (activeMigrations === 0) activeSince = now();
     activeMigrations += 1;
     let ended = false;
     return () => {
@@ -41,7 +58,7 @@ export function beginOffThreadMigration(): () => void {
         ended = true;
         activeMigrations -= 1;
         if (activeMigrations > 0) return;
-        accumulatedMs += Math.max(0, performance.now() - activeSince);
+        accumulatedMs += Math.max(0, now() - activeSince);
         const waiters = idleWaiters;
         idleWaiters = [];
         for (const wake of waiters) wake();
@@ -66,10 +83,10 @@ export interface BootDeadlineTimer {
  * still running.
  */
 export function startBootDeadline(timeoutMs: number, onDeferred?: () => void): BootDeadlineTimer {
-    const startedAt = performance.now();
+    const startedAt = now();
     const migratedAtStart = offThreadMigrationMs(startedAt);
     const budgetMs = Math.max(0, timeoutMs);
-    let timer: ReturnType<typeof setTimeout> | undefined;
+    let cancelTimer: (() => void) | undefined;
     let cancelled = false;
     let deferredReported = false;
     let resolveExpired!: () => void;
@@ -78,13 +95,14 @@ export function startBootDeadline(timeoutMs: number, onDeferred?: () => void): B
     });
 
     const remainingMs = (): number => {
-        const now = performance.now();
-        const countedMs = now - startedAt - (offThreadMigrationMs(now) - migratedAtStart);
+        const currentTime = now();
+        const countedMs =
+            currentTime - startedAt - (offThreadMigrationMs(currentTime) - migratedAtStart);
         return budgetMs - countedMs;
     };
 
     const check = (): void => {
-        timer = undefined;
+        cancelTimer = undefined;
         if (cancelled) return;
         if (isOffThreadMigrationRunning()) {
             if (!deferredReported) {
@@ -96,28 +114,34 @@ export function startBootDeadline(timeoutMs: number, onDeferred?: () => void): B
         }
         const left = remainingMs();
         if (left > 0) {
-            timer = setTimeout(check, left);
+            cancelTimer = scheduleTimeout(check, left);
             return;
         }
         resolveExpired();
     };
 
-    timer = setTimeout(check, budgetMs);
+    cancelTimer = scheduleTimeout(check, budgetMs);
     return {
         expired,
         cancel: () => {
             cancelled = true;
-            if (timer) clearTimeout(timer);
-            timer = undefined;
+            cancelTimer?.();
+            cancelTimer = undefined;
         },
     };
 }
 
+/** Inject deterministic time and timers in tests; production uses host APIs. */
+export function __setOffThreadMigrationClockForTests(clock?: TestClock): void {
+    testClock = clock;
+}
+
 /** Test seam: forget accumulated migration time between isolated tests. */
 export function __resetOffThreadMigrationClockForTests(): void {
     activeMigrations = 0;
     activeSince = 0;
     accumulatedMs = 0;
+    testClock = undefined;
     const waiters = idleWaiters;
     idleWaiters = [];
     for (const wake of waiters) wake();

package/src/shared/reclaim-distance.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, it } from "bun:test";
+import {
+    farBehindToolBookmark,
+    isReclaimUserTurn,
+    type ReclaimDistanceEntry,
+} from "./reclaim-distance";
+
+const output = (tag: number, tokens = 1000): ReclaimDistanceEntry => ({
+    toolOutputTag: tag,
+    tokens,
+});
+const turn = (): ReclaimDistanceEntry => ({ userTurn: true, tokens: 10 });
+
+describe("reclaim distance", () => {
+    it("repeated rebuilds cannot age the current task", () => {
+        const entries = [turn(), ...Array.from({ length: 28 }, (_, i) => output(i + 1))];
+        for (const count of [2, 3, 5]) {
+            let bookmark = 0;
+            for (let pass = 0; pass < count + 1; pass++) {
+                expect(bookmark).toBe(0);
+                bookmark = Math.max(bookmark, farBehindToolBookmark(entries, 200_000));
+            }
+        }
+    });
+
+    it("three newer user turns establish a bookmark, not two", () => {
+        const entries = [turn(), output(1), turn(), output(2), turn()];
+        expect(farBehindToolBookmark(entries, 200_000)).toBe(0);
+        expect(farBehindToolBookmark([...entries, turn()], 200_000)).toBe(1);
+    });
+
+    it("single-turn tool loop ages at exactly a quarter of the usable window", () => {
+        const entries = [turn(), output(1), output(2, 49_999)];
+        expect(farBehindToolBookmark(entries, 200_000)).toBe(0);
+        expect(farBehindToolBookmark([...entries, { tokens: 1 }], 200_000)).toBe(1);
+        expect(farBehindToolBookmark([turn(), output(1, 100_000)], 200_000)).toBe(0);
+    });
+
+    it("multipart outputs never age from their own trailing chunks", () => {
+        expect(farBehindToolBookmark([output(1), output(1, 60_000)], 200_000)).toBe(0);
+    });
+
+    it("unknown windows disable only token distance", () => {
+        expect(farBehindToolBookmark([output(1), output(2, 99_999)], 0)).toBe(0);
+        expect(farBehindToolBookmark([output(1), turn(), turn(), turn()], 0)).toBe(1);
+    });
+
+    it("excludes synthetic host wakes, MC reminders, heads and result carriers", () => {
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                parts: [
+                    {
+                        kind: "text",
+                        synthetic: true,
+                        text: "<system-reminder>Background task finished.</system-reminder>",
+                    },
+                ],
+            }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                parts: [
+                    {
+                        kind: "text",
+                        text: "<system-reminder>Your next step: call ctx_reduce on the outputs you've already used (5).</system-reminder>",
+                    },
+                ],
+            }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                syntheticHead: true,
+                parts: [{ kind: "text", text: "history" }],
+            }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({ role: "user", parts: [{ kind: "tool_result", text: "output" }] }),
+        ).toBe(false);
+        expect(
+            isReclaimUserTurn({
+                role: "user",
+                parts: [
+                    { kind: "tool_result", text: "output" },
+                    { kind: "text", text: "continue" },
+                ],
+            }),
+        ).toBe(true);
+    });
+
+    it("counts an authored part even after synthetic or ignored parts", () => {
+        for (const provenance of [{ synthetic: true }, { ignored: true }]) {
+            expect(
+                isReclaimUserTurn({ role: "user", parts: [{ kind: "image", ...provenance }] }),
+            ).toBe(false);
+            expect(
+                isReclaimUserTurn({
+                    role: "user",
+                    parts: [{ kind: "text", text: "notice", ...provenance }, { kind: "image" }],
+                }),
+            ).toBe(true);
+        }
+    });
+
+    it("a young lower-tag result holds back distant higher tags", () => {
+        expect(farBehindToolBookmark([output(2), output(3, 50_000), output(1)], 200_000)).toBe(0);
+        expect(farBehindToolBookmark([output(1), output(3, 50_000), output(2)], 200_000)).toBe(1);
+    });
+});