@cortexkit/opencode-magic-context 0.49.6 → 0.49.8

package/dist/wrapup-orchestrator-gv08c6f9.js

@@ -0,0 +1,47 @@
+import {
+  runManagedWrapup2
+} from "./index-pjgzdezw.js";
+import"./index-xf6k8szp.js";
+import"./index-hxrvx6cy.js";
+import"./index-s178h9z8.js";
+import"./index-ydjgz36f.js";
+import"./index-b4gcb3rk.js";
+import"./index-sd3egckz.js";
+import"./index-a43xq1pg.js";
+import"./index-n78avt2p.js";
+import"./index-rg1cezmj.js";
+import"./index-7bjgyaj1.js";
+import"./index-4dhv7mqz.js";
+import"./index-jw4gbfkv.js";
+import"./index-pgy3h49n.js";
+import"./index-qt1qqasc.js";
+import"./index-x8a7jmkh.js";
+import"./index-a4b0gbyg.js";
+import"./index-bmwfzz28.js";
+import"./index-kvw6xew3.js";
+import"./index-zf9nydbd.js";
+import"./index-qgp5vnt4.js";
+import"./index-fb3zxn06.js";
+import"./index-fr0wbhdn.js";
+import"./index-0jz47061.js";
+import"./index-mp2kghkv.js";
+import"./index-q28hsbpg.js";
+import"./index-9g1c4bt9.js";
+import"./index-xpn05jxq.js";
+import"./index-1zx87sdm.js";
+import"./index-q76br5zn.js";
+import"./index-angx1s0k.js";
+import"./index-v0p37hm2.js";
+import"./index-w28y7d0z.js";
+import"./index-8kk7yh6m.js";
+import"./index-bd9cjab3.js";
+import"./index-58e3y90n.js";
+import"./index-150zz6fh.js";
+import"./index-gjvjh960.js";
+import"./index-wafzvyhg.js";
+import"./index-mvvephtj.js";
+import"./index-0sahzkwr.js";
+import"./index-pavzsdc6.js";
+export {
+  runManagedWrapup2 as runManagedWrapup
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.49.6",
+  "version": "0.49.8",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -43,8 +43,8 @@
     "check:tui-compiled": "git diff --exit-code -- src/tui-compiled && test -z \"$(git status --porcelain -- src/tui-compiled)\"",
     "check:transformers-node-wasm": "bun scripts/verify-transformers-node-wasm.ts",
     "typecheck": "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit && tsc -p tsconfig.scripts.json",
-    "test": "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
-    "test:serial": "bun install --frozen-lockfile && BUN_JSC_useOMGJIT=0 bun test --timeout 30000",
+    "test": "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && MC_REVIEW_ASSERT_LIVENESS=1 BUN_JSC_useOMGJIT=0 bun test --parallel=4 --timeout 30000",
+    "test:serial": "bun install --frozen-lockfile && MC_REVIEW_ASSERT_LIVENESS=1 BUN_JSC_useOMGJIT=0 bun test --timeout 30000",
     "test:parallel:probe": "bun scripts/verify-parallel-db-isolation.ts",
     "lint": "bun ../../scripts/check-bun.mjs && biome check .",
     "lint:fix": "biome check --write .",

package/src/config/compaction-accessor-guard.test.ts

@@ -32,6 +32,9 @@ const ALLOWED_READERS = new Set<string>([
     "packages/cli/src/lib/omp-helpers.ts",
     "packages/cli/src/commands/setup-omp.ts",
     "packages/cli/src/commands/doctor-omp.ts",
+    // The privacy projection recognizes the setting's name in diagnostic text;
+    // it never reads the parsed configuration value.
+    "packages/cli/src/lib/issue-privacy.ts",
 ]);
 
 function sourceFiles(directory: string): string[] {

package/src/features/magic-context/dreamer/cron.ts

@@ -61,6 +61,13 @@ const MINUTE_MS = 60_000;
  */
 const MAX_SEARCH_MS = 4 * 366 * 24 * 60 * MINUTE_MS;
 
+let candidateVisitsForTests: (() => void) | undefined;
+
+/** Count searched minutes in tests without affecting normal cron callers. */
+export function __setCronCandidateVisitCounterForTests(counter?: () => void): void {
+    candidateVisitsForTests = counter;
+}
+
 /** Parse one field into the set of matching values, or null on error. */
 function parseField(token: string, spec: FieldSpec): Set<number> | null {
     const values = new Set<number>();
@@ -226,6 +233,7 @@ export function nextOccurrence(
     const capMs = afterMs + Math.max(0, Math.min(MAX_SEARCH_MS, maxSearchMs));
 
     while (cursorMs <= capMs) {
+        candidateVisitsForTests?.();
         const candidate = new Date(cursorMs);
         if (matchesCron(cron, candidate)) {
             if (!excludeCivilMinute || civilMinuteKey(candidate) !== excludeCivilMinute) {

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/processed-image-eligibility.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "bun:test";
+import { createProcessedImageEligibility } from "./processed-image-eligibility";
+
+const messages = ["old", "image", "answer", "tail"];
+
+test("image position age inherits its next positive tag, never zero or an earlier tag", () => {
+    const policy = createProcessedImageEligibility(
+        messages,
+        new Map([
+            ["old", 1],
+            ["answer", 6],
+        ]),
+        { watermark: 1 },
+    );
+    expect(policy.ageTags.get("image")).toBe(6);
+    expect(policy.mayStrip("image")).toBe(false);
+    expect(policy.ageTags.has("tail")).toBe(false);
+    expect(policy.mayStrip("tail")).toBe(false);
+    const own = createProcessedImageEligibility(
+        messages,
+        new Map([
+            ["image", 3],
+            ["answer", 6],
+        ]),
+        { watermark: 4 },
+    );
+    expect(own.ageTags.get("image")).toBe(3);
+    expect(own.mayStrip("image")).toBe(true);
+});
+
+test("answered image-only positions outside the protected window are eligible", () => {
+    const policy = createProcessedImageEligibility(
+        messages,
+        new Map([
+            ["answer", 3],
+            ["tail", 5],
+        ]),
+        { watermark: 4, protectedCutoff: 5, contextPercentage: 94.99 },
+    );
+    expect(policy.ageTags.get("image")).toBe(3);
+    expect(policy.mayStrip("image")).toBe(true);
+});
+
+test("image positions inside the protected window stay below the 95 percent emergency", () => {
+    const policy = createProcessedImageEligibility(messages, new Map([["answer", 6]]), {
+        watermark: 10,
+        protectedCutoff: 5,
+        contextPercentage: 94.99,
+    });
+    expect(policy.mayStrip("image")).toBe(false);
+});
+
+test("image positions follow emergency drops when the newest window yields at 95 percent", () => {
+    for (const contextPercentage of [95, 99]) {
+        const policy = createProcessedImageEligibility(messages, new Map([["answer", 6]]), {
+            watermark: 10,
+            protectedCutoff: 5,
+            contextPercentage,
+        });
+        expect(policy.mayStrip("image")).toBe(true);
+        const notDroppedYet = createProcessedImageEligibility(messages, new Map([["answer", 11]]), {
+            watermark: 10,
+            protectedCutoff: 5,
+            contextPercentage,
+        });
+        expect(notDroppedYet.mayStrip("image")).toBe(false);
+    }
+});

package/src/shared/processed-image-eligibility.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared processed-image age and recency policy for both OpenCode adapters.
+ * Use the owning message's positive maximum tag; an untagged image-only message
+ * inherits the next positive tagged message after it, never age zero or a tag
+ * from an earlier message. Without either tag, retain the image at the live tail.
+ * A positive dropped-tag watermark must cover that position. Below 95% usage,
+ * retain every position at or beyond the protected newest-window cutoff. At
+ * 95% and above only that window yields, exactly as for emergency tool drops;
+ * independent per-tool protections still apply. Content before retained provider-signed
+ * thinking must stay unchanged unless an existing whole-turn rewrite removes that
+ * thinking first. Callers enforce these protections, later-assistant/stable-id checks, durable
+ * persistence and rewrite-only discovery. Frozen replay bypasses eligibility.
+ */
+export function createProcessedImageEligibility<T>(
+    messages: readonly T[],
+    messageTagNumbers: ReadonlyMap<T, number>,
+    options: { watermark: number; protectedCutoff?: number | null; contextPercentage?: number },
+): { ageTags: ReadonlyMap<T, number>; mayStrip: (message: T) => boolean } {
+    const ageTags = new Map<T, number>();
+    let nextTag: number | undefined;
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        const ownTag = messageTagNumbers.get(message);
+        if (ownTag !== undefined && Number.isFinite(ownTag) && ownTag > 0) nextTag = ownTag;
+        if (nextTag !== undefined) ageTags.set(message, nextTag);
+    }
+    return {
+        ageTags,
+        mayStrip: (message) => {
+            const age = ageTags.get(message);
+            return (
+                options.watermark > 0 &&
+                age !== undefined &&
+                age <= options.watermark &&
+                ((options.contextPercentage ?? 0) >= 95 ||
+                    options.protectedCutoff == null ||
+                    age < options.protectedCutoff)
+            );
+        },
+    };
+}

package/src/shared/processed-image-position-review.json

@@ -0,0 +1,20 @@
+[
+    { "name": "own maximum wins over a later smaller tag", "tags": [[2, 10, 4], [3]], "target": 0, "watermark": 8, "cutoff": null, "percentage": 60, "age": 10, "eligible": false },
+    { "name": "own maximum at watermark", "tags": [[2, 10, 4], [30]], "target": 0, "watermark": 10, "cutoff": null, "percentage": 60, "age": 10, "eligible": true },
+    { "name": "first later tag not largest later tag", "tags": [[], [3], [20]], "target": 0, "watermark": 3, "cutoff": null, "percentage": 60, "age": 3, "eligible": true },
+    { "name": "first later message contributes its own maximum", "tags": [[], [2, 9], [3]], "target": 0, "watermark": 5, "cutoff": null, "percentage": 60, "age": 9, "eligible": false },
+    { "name": "skip empty and zero tags when looking forward", "tags": [[1], [], [0], [4]], "target": 1, "watermark": 4, "cutoff": null, "percentage": 60, "age": 4, "eligible": true },
+    { "name": "zero own tag inherits later positive", "tags": [[0], [7]], "target": 0, "watermark": 6, "cutoff": null, "percentage": 60, "age": 7, "eligible": false },
+    { "name": "preceding tag cannot age live tail", "tags": [[1], [], []], "target": 1, "watermark": 100, "cutoff": null, "percentage": 60, "age": null, "eligible": false },
+    { "name": "all untagged is ineligible", "tags": [[], []], "target": 0, "watermark": 100, "cutoff": null, "percentage": 60, "age": null, "eligible": false },
+    { "name": "watermark zero even with emergency", "tags": [[], [1]], "target": 0, "watermark": 0, "cutoff": 1, "percentage": 95, "age": 1, "eligible": false },
+    { "name": "age above watermark even with emergency", "tags": [[], [7]], "target": 0, "watermark": 6, "cutoff": 1, "percentage": 100, "age": 7, "eligible": false },
+    { "name": "cutoff inclusive at 94.99 percent", "tags": [[5], [8]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 94.99, "age": 5, "eligible": false },
+    { "name": "inside cutoff is a range not set membership", "tags": [[], [6]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 60, "age": 6, "eligible": false },
+    { "name": "below cutoff is eligible", "tags": [[4], [8]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 94.99, "age": 4, "eligible": true },
+    { "name": "exactly 95 waives cutoff", "tags": [[], [6]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 95, "age": 6, "eligible": true },
+    { "name": "above 95 waives cutoff", "tags": [[5], [8]], "target": 0, "watermark": 9, "cutoff": 5, "percentage": 95.01, "age": 5, "eligible": true },
+    { "name": "emergency cannot invent tail age", "tags": [[1], []], "target": 1, "watermark": 100, "cutoff": 1, "percentage": 100, "age": null, "eligible": false },
+    { "name": "own positive tag overrides later greater tag", "tags": [[2], [20]], "target": 0, "watermark": 2, "cutoff": 3, "percentage": 60, "age": 2, "eligible": true },
+    { "name": "last message with own tag is aged", "tags": [[1], [4]], "target": 1, "watermark": 4, "cutoff": null, "percentage": 60, "age": 4, "eligible": true }
+]

package/src/shared/processed-image-position-review.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import { createProcessedImageEligibility } from "./processed-image-eligibility";
+import cases from "./processed-image-position-review.json";
+
+// OpenCode, Rust and Pi can reuse these cases: each row supplies per-message
+// tag numbers rather than provider-specific message objects or image encodings.
+for (const row of cases) {
+    test(`independent image position table: ${row.name}`, () => {
+        const messages = row.tags.map((_, i) => `message-${i}`);
+        const tags = new Map(messages.map((message, i) => [message, Math.max(0, ...row.tags[i])]));
+        const policy = createProcessedImageEligibility(messages, tags, {
+            watermark: row.watermark,
+            protectedCutoff: row.cutoff,
+            contextPercentage: row.percentage,
+        });
+        expect(policy.ageTags.get(messages[row.target]) ?? null).toBe(row.age);
+        expect(policy.mayStrip(messages[row.target])).toBe(row.eligible);
+    });
+}