@retaw106/mmc-oc 2.2.1 → 2.4.0

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);
+    });
+}

package/src/shared/project-directory-key.ts

@@ -20,6 +20,26 @@ export function projectDirectoryKey(directory: string): string {
     return path.resolve(directory);
 }
 
+/**
+ * Whether two spellings name the same directory, judged by spelling alone.
+ *
+ * Hosts and the plugin do not agree on how to write a directory: OpenCode 2 on
+ * Windows stores a session's directory as `D:/work/app` while the plugin's own
+ * location is `D:\work\app`, and a drive letter can arrive in either case.
+ * Both sides go through `projectDirectoryKey`, so separators, Windows case,
+ * `\\?\` prefixes, trailing separators and `.`/`..` segments cannot make one
+ * directory look like two. POSIX paths keep their case. Symlinks are not
+ * resolved here; callers that must follow them use `canonicalProjectDirectory`.
+ *
+ * An empty spelling never matches anything: `path.resolve("")` is the process's
+ * working directory, and a session with no recorded directory must not be
+ * taken for one in the directory the process happens to run in.
+ */
+export function sameProjectDirectory(a: string, b: string): boolean {
+    if (a.length === 0 || b.length === 0) return false;
+    return projectDirectoryKey(a) === projectDirectoryKey(b);
+}
+
 let realpathForCanonicalDirectory: (directory: string) => string = (directory) =>
     realpathSync.native(directory);
 

package/src/shared/prompt-surface-runtime.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { readFileSync, statSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 
@@ -59,6 +60,17 @@ export function promptSurfaceHashMaterial(
         : `${systemContent}\n\0magic-context-prompt-surface:${preset}`;
 }
 
+/**
+ * Hash system text after the caller resolves guidance and freezes host date lines.
+ * Keep the legacy MD5 hex encoding so existing cached heads retain their identity.
+ */
+export function systemPromptFingerprint(
+    systemContent: string,
+    preset: PromptSurfacePreset = "full",
+): string {
+    return createHash("md5").update(promptSurfaceHashMaterial(systemContent, preset)).digest("hex");
+}
+
 const PROMPT_SURFACE_TOOL_ID_SET = new Set<string>(ACTIVE_TOOL_IDS);
 
 export interface PromptSurfaceGuidanceSelection {

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);
+    });
+});

package/src/shared/reclaim-distance.ts

@@ -0,0 +1,91 @@
+export const RECLAIM_DISTANCE_USER_TURNS = 3;
+export const RECLAIM_DISTANCE_WINDOW_FRACTION = 0.25;
+
+export interface ReclaimDistanceEntry {
+    /** Local content tokens, excluding Magic Context's history and reduction/note reminders. */
+    tokens: number;
+    /** One event per authored user-role message, after any folded tool results. */
+    userTurn?: boolean;
+    /** Durable identifier of the tool invocation whose result ends at this entry. */
+    toolOutputTag?: number;
+}
+
+/** Only authored content starts a user turn; host control notices do not. */
+export function isReclaimUserTurn(args: {
+    role?: string;
+    syntheticHead?: boolean;
+    synthetic?: boolean;
+    ignored?: boolean;
+    parts: readonly { kind: string; text?: string; synthetic?: boolean; ignored?: boolean }[];
+}): boolean {
+    return (
+        args.role === "user" &&
+        !args.syntheticHead &&
+        !args.synthetic &&
+        !args.ignored &&
+        args.parts.some((part) => {
+            if (part.synthetic || part.ignored) return false;
+            if (part.kind !== "text" && part.kind !== "image" && part.kind !== "file") return false;
+            if (part.kind !== "text") return true;
+            return stripReclaimMcText(part.text ?? "").trim().length > 0;
+        })
+    );
+}
+
+/** Remove Magic Context's reduction/note reminders, not generic host wake notices. */
+export function stripReclaimMcText(text: string): string {
+    return text
+        .replace(/^§\d+§\s*/, "")
+        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, (reminder) =>
+            /^(?:Your next step: call ctx_reduce on the outputs you've already used|Still unstamped:|Housekeeping: .* are reclaimable\. Stamp each output with ctx_reduce|.* are reclaimable\. Make a ctx_reduce pass now|.* are still unstamped\. Call ctx_reduce now)/.test(
+                reminder.slice("<system-reminder>".length).trimStart(),
+            )
+                ? ""
+                : reminder,
+        )
+        .replace(/<instruction name="deferred_notes">[\s\S]*?<\/instruction>/g, "");
+}
+
+/**
+ * A free cache rebuild is not evidence that the model has moved on. An output
+ * is far behind only after three newer user turns or a quarter-window of newer
+ * content. Return a prefix of qualifying tags; callers drop against the PREVIOUS
+ * durable bookmark before advancing it, so distance must survive two rebuilds.
+ */
+export function farBehindToolBookmark(
+    entries: readonly ReclaimDistanceEntry[],
+    usableWindow: number,
+): number {
+    let newerTurns = 0;
+    let newerTokens = 0;
+    const farTags: number[] = [];
+    let firstYoungTag = Infinity;
+    const seenOutputs = new Set<number>();
+    const tokenDistance =
+        usableWindow > 0 && Number.isFinite(usableWindow)
+            ? usableWindow * RECLAIM_DISTANCE_WINDOW_FRACTION
+            : Infinity;
+    for (let index = entries.length - 1; index >= 0; index--) {
+        const entry = entries[index];
+        if (!entry) continue;
+        const tag = entry.toolOutputTag;
+        // Multi-part outputs are positioned at their last result, not their call
+        // or first chunk: an output must never count its own remaining payload.
+        if (tag !== undefined && !seenOutputs.has(tag)) {
+            seenOutputs.add(tag);
+            if (newerTurns >= RECLAIM_DISTANCE_USER_TURNS || newerTokens >= tokenDistance) {
+                farTags.push(tag);
+            } else {
+                firstYoungTag = Math.min(firstYoungTag, tag);
+            }
+        }
+        if (entry.userTurn) newerTurns++;
+        if (Number.isFinite(entry.tokens) && entry.tokens > 0) newerTokens += entry.tokens;
+    }
+    // Tags follow call order, not result arrival. A late lower-tag sibling must
+    // hold the prefix even when a higher-tag result is already distant.
+    return farTags.reduce(
+        (bookmark, tag) => (tag < firstYoungTag ? Math.max(bookmark, tag) : bookmark),
+        0,
+    );
+}

package/src/shared/recovery-reasoning-prefix.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from "bun:test";
+import { recoveryReasoningPrefixes } from "./recovery-reasoning-prefix";
+
+for (const key of ["content", "parts"] as const) {
+    test(`recovery reasoning ${key}: exact preceding messages and same-message parts`, () => {
+        const messages = [
+            { role: "user", [key]: [{ type: "text", text: "original" }] },
+            {
+                role: "assistant",
+                [key]: [
+                    { type: "text", text: "before" },
+                    { type: "thinking", thinkingSignature: "first" },
+                    { type: "text", text: "between" },
+                    { type: "redacted_thinking", data: "opaque" },
+                    { type: "text", text: "after" },
+                ],
+            },
+        ];
+        const original = recoveryReasoningPrefixes(messages, key);
+        expect(original).toHaveLength(2);
+        const edited = structuredClone(messages);
+        edited[0]![key]![0]!.text = "changed";
+        expect(recoveryReasoningPrefixes(edited, key)).not.toEqual(original);
+        const parts = structuredClone(messages);
+        parts[1]![key]![2]!.text = "changed";
+        expect(recoveryReasoningPrefixes(parts, key)[0]).toBe(original[0]);
+        expect(recoveryReasoningPrefixes(parts, key)[1]).not.toBe(original[1]);
+        const suffix = structuredClone(messages);
+        suffix[1]![key]![4]!.text = "changed";
+        expect(recoveryReasoningPrefixes(suffix, key)).toEqual(original);
+        suffix[1]![key]!.splice(3, 1);
+        expect(recoveryReasoningPrefixes(suffix, key)).not.toEqual(original);
+    });
+}

package/src/shared/recovery-reasoning-prefix.ts

@@ -0,0 +1,35 @@
+/**
+ * Serialize each request prefix ending at a thinking/reasoning part, including
+ * earlier messages and earlier parts of that message. Comparing these snapshots
+ * detects edits to bytes authenticated by a kept signature, or missing blocks.
+ * Include reasoning without a visible signature too: a host may carry its
+ * provider signature in fields this helper does not interpret.
+ */
+export function recoveryReasoningPrefixes(
+    messages: readonly unknown[],
+    partsKey: "parts" | "content",
+): string[] {
+    const prefixes: string[] = [];
+    for (let index = 0; index < messages.length; index++) {
+        const message = messages[index] as Record<string, unknown> | null;
+        const parts = message?.[partsKey];
+        if (!Array.isArray(parts)) continue;
+        for (let p = 0; p < parts.length; p++) {
+            const type = (parts[p] as { type?: string } | null)?.type;
+            if (
+                type !== "thinking" &&
+                type !== "reasoning" &&
+                type !== "redactedThinking" &&
+                type !== "redacted_thinking"
+            )
+                continue;
+            prefixes.push(
+                JSON.stringify([
+                    ...messages.slice(0, index),
+                    { ...message, [partsKey]: parts.slice(0, p + 1) },
+                ]),
+            );
+        }
+    }
+    return prefixes;
+}

package/src/shared/root-async-context.probe.mjs

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { setTimeout as delay, setImmediate as tick } from "node:timers/promises";
+import { Worker } from "node:worker_threads";
+import { inRootAsyncContext } from "./sqlite";
+
+const scope = new AsyncLocalStorage();
+const gc = globalThis.Bun ? () => Bun.gc(true) : globalThis.gc;
+const references = {};
+const resources = [];
+const timerStores = {};
+const ambientTick = () => { timerStores.ambient = scope.getStore() !== undefined; };
+const rootTick = () => { timerStores.root = scope.getStore() !== undefined; };
+function create(name, root, worker) {
+    const payload = { synthetic: name };
+    references[name] = new WeakRef(payload);
+    scope.run(payload, () => {
+        const make = worker
+            ? () => new Worker(new URL("worker.mjs", import.meta.url))
+            : () => setInterval(root ? rootTick : ambientTick, 5);
+        resources.push(root ? inRootAsyncContext(make) : make());
+        assert.equal(scope.getStore(), payload, "Root execution must restore the caller's store");
+    });
+}
+create("ambientWorker", false, true);
+create("rootWorker", true, true);
+create("ambientTimer", false, false);
+create("rootTimer", true, false);
+await delay(30);
+for (let i = 0; i < 12; i++) { await tick(); gc(); await tick(); }
+const retained = Object.fromEntries(Object.entries(references).map(([key, ref]) => [key, Number(ref.deref() !== undefined)]));
+for (const resource of resources) {
+    if (resource instanceof Worker) await resource.terminate();
+    else clearInterval(resource);
+}
+console.log(JSON.stringify({ runtime: globalThis.Bun ? `Bun ${Bun.version}` : process.version, timerStores, retained }));

package/src/shared/root-async-context.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test";
+import { rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createTestTempDirFromPath } from "./test-temp-dir";
+
+for (const runtime of ["Node", "Bun"] as const) {
+    test(`root resources do not inherit request stores (${runtime})`, async () => {
+        const directory = createTestTempDirFromPath(join(tmpdir(), "root-context-"));
+        try {
+            const entry = join(directory, "probe.mjs");
+            const build = await Bun.build({
+                entrypoints: [new URL("root-async-context.probe.mjs", import.meta.url).pathname],
+                target: "node",
+                format: "esm",
+                external: ["bun:sqlite", "node:sqlite"],
+            });
+            expect(build.success).toBe(true);
+            await writeFile(entry, await build.outputs[0].text());
+            await writeFile(
+                join(directory, "worker.mjs"),
+                `import { parentPort } from 'node:worker_threads'; parentPort.on('message', () => {});`,
+            );
+            const child = Bun.spawn(
+                [...(runtime === "Node" ? ["node", "--expose-gc"] : [process.execPath]), entry],
+                {
+                    stdout: "pipe",
+                    stderr: "pipe",
+                    windowsHide: true,
+                },
+            );
+            const [stdout, stderr, exit] = await Promise.all([
+                new Response(child.stdout).text(),
+                new Response(child.stderr).text(),
+                child.exited,
+            ]);
+            expect(exit, stderr).toBe(0);
+            const result = JSON.parse(stdout);
+            console.log(`${runtime} ALS propagation: ${stdout.trim()}`);
+            expect(result.timerStores).toEqual({ ambient: true, root: false });
+            expect(result.retained.rootWorker).toBe(0);
+            expect(result.retained.rootTimer).toBe(0);
+            expect(result.retained.ambientTimer).toBe(1);
+            if (runtime === "Node") expect(result.retained.ambientWorker).toBe(1);
+        } finally {
+            await rm(directory, { recursive: true, force: true });
+        }
+    });
+}

package/src/shared/sqlite-acquisition-routing.test.ts

@@ -118,7 +118,7 @@ test("exhausted routed acquisition never enters the callback or multiplies privi
         db.close();
         rmSync(dir, { recursive: true, force: true });
     }
-});
+}, 30_000);
 
 for (const mode of ["run", "get", "all", "exec"] as const) {
     test(`foreground ${mode} autocommit waits share one turn budget and restore production timeout`, () => {
@@ -147,7 +147,8 @@ for (const mode of ["run", "get", "all", "exec"] as const) {
                 }
                 expect(() => db.exec("BEGIN IMMEDIATE")).toThrow("acquisition remained busy");
             });
-            expect(performance.now() - started).toBeLessThan(650);
+            expect(performance.now() - started).toBeGreaterThanOrEqual(1900);
+            expect(performance.now() - started).toBeLessThan(2600);
             expect(db.prepare("PRAGMA busy_timeout").get()).toEqual({ timeout: 5000 });
             expect(db.prepare("SELECT * FROM result").all()).toEqual([]);
             blocker.exec("ROLLBACK");
@@ -159,5 +160,5 @@ for (const mode of ["run", "get", "all", "exec"] as const) {
             db.close();
             rmSync(dir, { recursive: true, force: true });
         }
-    });
+    }, 30_000);
 }