@retaw106/mmc-oc 2.3.0 → 2.4.0

package/src/shared/sqlite.ts

@@ -39,7 +39,7 @@
  * `run()` → {changes,lastInsertRowid}) is identical and was verified directly.
  */
 
-import { AsyncLocalStorage } from "node:async_hooks";
+import { AsyncLocalStorage, AsyncResource } from "node:async_hooks";
 import { statSync } from "node:fs";
 // Type import only — runtime is loaded dynamically below. @types/better-sqlite3
 // has the richest definitions and is a structural superset of the API surface
@@ -47,6 +47,16 @@ import { statSync } from "node:fs";
 // node:sqlite at runtime (both expose prepare/run/get/all/exec/close).
 import type BetterSqlite3 from "better-sqlite3";
 
+// Capture the root before creating request-local AsyncLocalStorage scopes.
+// Shared workers and timers must not inherit callbacks that reject stale
+// database writes: those callbacks can retain an obsolete request's inputs.
+const resourceRoot = new AsyncResource("magic-context:root");
+
+/** Create host-owned resources without inheriting request-local state. */
+export function inRootAsyncContext<T>(operation: () => T): T {
+    return resourceRoot.runInAsyncScope(operation);
+}
+
 /**
  * Slow-write reporting is injected rather than imported: this module is also
  * executed directly by Node (the `node:sqlite` smoke in CI, Pi, Desktop), and
@@ -419,7 +429,9 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
                 !/^\s*(?:SELECT|EXPLAIN|PRAGMA|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(sql)
             ) {
                 try {
-                    return withAutocommitTimeout(db, () => nativeExec(sql));
+                    // exec can commit a script prefix before BUSY. Run it once;
+                    // only prepared statements are safe to probe and retry.
+                    return withAutocommitTimeout(db, () => nativeExec(sql), false);
                 } finally {
                     if (mayChangeTagIdentity(sql)) tagIdentityWriteGeneration += 1;
                 }
@@ -586,7 +598,9 @@ function trackSqliteConnection(
 
 const TrackedDatabase = new Proxy(DatabaseImpl, {
     construct(target, args) {
-        const db = Reflect.construct(target, args, target) as BetterSqlite3.Database;
+        const db = inRootAsyncContext(
+            () => Reflect.construct(target, args, target) as BetterSqlite3.Database,
+        );
         return trackSqliteConnection(db, args[0], args[1]);
     },
 }) as typeof BetterSqlite3;
@@ -999,33 +1013,60 @@ function foregroundWaitLease() {
         : undefined;
 }
 
-/** Bound implicit writer admission too, including prepared INSERT OR IGNORE and
- * writes with RETURNING. Charge successful execution time conservatively: the
- * native API cannot separate lock waiting from statement execution. Exhaustion
- * switches to zero-wait acquisition, not a refusal when the writer is free. */
-function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
+/** Probe a prepared statement's writer lock without charging uncontended work
+ * against the foreground lock-wait budget. An exec script may commit some of
+ * its statements before failing, so it cannot be retried without duplicating
+ * writes; conservatively charge its single attempt's full execution time. */
+function withAutocommitTimeout<T>(db: Database, operation: () => T, singleStatement = true): T {
     assertTransformWrite();
     const lease = foregroundWaitLease();
     if (isInTransaction(db)) return operation();
     const scoped = lease || backgroundWriterScope.getStore();
     const previous = scoped ? pragmaNumber(db, "busy_timeout") : null;
-    if (scoped)
-        db.exec(
-            `PRAGMA busy_timeout=${lease ? Math.floor(Math.min(lease.remainingWaitMs, lease.guard?.remainingMs() ?? Infinity)) : SHORT_BUSY_TIMEOUT_MS}`,
-        );
     const started = performance.now();
     let completed = false;
-    try {
+    const execute = () => {
         const result = operation();
         completed = true;
         return result;
+    };
+    try {
+        if (!scoped) return execute();
+        if (singleStatement) {
+            db.exec("PRAGMA busy_timeout=0");
+            try {
+                return execute();
+            } catch (error) {
+                if (!isTransientSqliteError(error) || isInTransaction(db)) throw error;
+            }
+            assertTransformWrite();
+        }
+        const timeout = Math.floor(
+            Math.min(
+                lease?.remainingWaitMs ?? SHORT_BUSY_TIMEOUT_MS,
+                lease?.guard?.remainingMs() ?? Infinity,
+            ),
+        );
+        db.exec(`PRAGMA busy_timeout=${timeout}`);
+        const waitStarted = performance.now();
+        try {
+            return execute();
+        } finally {
+            // Deduct the prepared statement's contended retry or the exec
+            // script's execution from the remaining foreground wait budget;
+            // the native API cannot separate lock waiting from execution.
+            if (lease)
+                lease.remainingWaitMs = Math.max(
+                    0,
+                    lease.remainingWaitMs - (performance.now() - waitStarted),
+                );
+        }
     } catch (error) {
         if (lease && isTransientSqliteError(error))
             throw new SqliteAcquisitionBusyError(error, "autocommit");
         throw error;
     } finally {
         const elapsed = performance.now() - started;
-        if (lease) lease.remainingWaitMs = Math.max(0, lease.remainingWaitMs - elapsed);
         if (previous !== null) db.exec(`PRAGMA busy_timeout=${previous}`);
         // Native autocommit does not expose the instant its lock was acquired.
         // Label the upper bound so a waiting statement is not blamed as a holder.

package/src/shared/stable-json.ts

@@ -22,33 +22,33 @@ export function stableStringify(value: unknown, seen = new WeakSet<object>()): s
     // value's text once per enclosing level, so a large value N levels deep cost
     // N copies of itself.
     const pieces: string[] = [];
-    writeStable(value, seen, pieces);
+    writeStable(value, seen, (piece) => pieces.push(piece));
     return pieces.join("");
 }
 
-function writeStable(value: unknown, seen: WeakSet<object>, pieces: string[]): void {
+function writeStable(value: unknown, seen: WeakSet<object>, write: (piece: string) => void): void {
     if (value === undefined) {
-        pieces.push("undefined");
+        write("undefined");
         return;
     }
     if (value === null || typeof value !== "object") {
-        pieces.push(JSON.stringify(value) ?? String(value));
+        write(JSON.stringify(value) ?? String(value));
         return;
     }
     // Any object met a second time, shared or cyclic, is written as "[Circular]".
     if (seen.has(value)) {
-        pieces.push('"[Circular]"');
+        write('"[Circular]"');
         return;
     }
     seen.add(value);
     if (Array.isArray(value)) {
-        pieces.push("[");
+        write("[");
         for (let index = 0; index < value.length; index += 1) {
-            if (index > 0) pieces.push(",");
+            if (index > 0) write(",");
             // A hole writes nothing between its commas, as joining a mapped array did.
-            if (index in value) writeStable(value[index], seen, pieces);
+            if (index in value) writeStable(value[index], seen, write);
         }
-        pieces.push("]");
+        write("]");
         return;
     }
     // Code-point sort (NOT localeCompare). Stable across runtimes/locales.
@@ -57,11 +57,53 @@ function writeStable(value: unknown, seen: WeakSet<object>, pieces: string[]): v
         if (a > b) return 1;
         return 0;
     });
-    pieces.push("{");
+    // Native JSON can emit a small scalar-only object in one operation. Larger
+    // containers still stream; undefined and integer keys need the writer's
+    // non-native spelling/order. Bound chunks so hashing never builds a large JSON string.
+    if (
+        entries.length > 0 &&
+        entries.length <= 16 &&
+        entries.every(
+            ([key, child]) =>
+                key.length <= 4096 &&
+                !/^(0|[1-9]\d*)$/.test(key) &&
+                (child === null ||
+                    typeof child === "number" ||
+                    typeof child === "boolean" ||
+                    (typeof child === "string" && child.length <= 4096)),
+        )
+    ) {
+        write(JSON.stringify(Object.fromEntries(entries)));
+        return;
+    }
+    write("{");
     entries.forEach(([key, child], index) => {
-        if (index > 0) pieces.push(",");
-        pieces.push(JSON.stringify(key), ":");
-        writeStable(child, seen, pieces);
+        if (index > 0) write(",");
+        write(JSON.stringify(key));
+        write(":");
+        writeStable(child, seen, write);
     });
-    pieces.push("}");
+    write("}");
+}
+
+/** The existing UTF-16 FNV fingerprint, without retaining the serialized JSON. */
+export function stableStringifyHash(value: unknown, prefix = ""): string {
+    const sink = jsonHashSink(prefix);
+    writeStable(value, new WeakSet(), sink.write);
+    return sink.digest();
+}
+
+/** Hash the same code units as the content memo, including lone surrogates. */
+export function jsonHashSink(prefix = ""): {
+    write: (piece: string) => void;
+    digest: () => string;
+} {
+    let hash = 0x811c9dc5;
+    const write = (piece: string): void => {
+        for (let index = 0; index < piece.length; index++) {
+            hash = Math.imul(hash ^ piece.charCodeAt(index), 0x01000193);
+        }
+    };
+    write(prefix);
+    return { write, digest: () => (hash >>> 0).toString(16).padStart(8, "0") };
 }

package/src/shared/tail-hygiene-json.test.ts

@@ -0,0 +1,117 @@
+import { expect, test } from "bun:test";
+import { jsonHashSink, stableStringify, stableStringifyHash } from "./stable-json";
+import { piJsonHash, TailHygieneJsonMemo } from "./tail-hygiene-json";
+
+function hash(text: string): string {
+    const sink = jsonHashSink("excluded\0");
+    sink.write(text);
+    return sink.digest();
+}
+
+function piStringify(value: unknown): string {
+    const seen = new Set<object>();
+    try {
+        return (
+            JSON.stringify(value, (_key, current) => {
+                if (!current || typeof current !== "object" || Array.isArray(current))
+                    return current;
+                if (seen.has(current)) return "[Circular]";
+                seen.add(current);
+                return Object.fromEntries(
+                    Object.entries(current).sort(([a], [b]) => a.localeCompare(b)),
+                );
+            }) ?? ""
+        );
+    } catch {
+        return "";
+    }
+}
+
+test("streamed excluded fingerprints equal both original serializers on randomized values", () => {
+    let state = 704;
+    const random = (n: number): number => {
+        state = (Math.imul(state, 1664525) + 1013904223) | 0;
+        return (state >>> 0) % n;
+    };
+    const leaves = [
+        undefined,
+        null,
+        -0,
+        NaN,
+        Infinity,
+        1e-7,
+        1e23,
+        false,
+        "\ud800",
+        "é😀\n\u2028",
+        '"\\',
+    ];
+    const generate = (depth: number): unknown => {
+        if (!depth || random(3) === 0) return leaves[random(leaves.length)];
+        if (random(2)) {
+            const array = new Array(4);
+            array[0] = generate(depth - 1);
+            array[2] = undefined;
+            array[3] = generate(depth - 1);
+            return array;
+        }
+        const value: Record<string, unknown> = {};
+        const keys = ["10", "2", "Z", "ä", "a", "e\u0301", "é"];
+        for (let i = 0; i < 4; i++) value[keys[random(keys.length)]] = generate(depth - 1);
+        if (random(5) === 0) value.self = value;
+        return value;
+    };
+    const shared = { a: undefined, z: "shared" };
+    const cycle: unknown[] = [];
+    cycle.push(cycle);
+    const samples: unknown[] = [
+        cycle,
+        { a: shared, b: shared },
+        1n,
+        new Date(0),
+        { toJSON: () => "date" },
+    ];
+    for (let i = 0; i < 2_000; i++) samples.push(generate(4));
+    for (const value of samples) {
+        try {
+            const expected = stableStringify(value);
+            expect(stableStringifyHash(value, "excluded\0")).toBe(hash(expected));
+        } catch {
+            expect(() => stableStringifyHash(value, "excluded\0")).toThrow();
+        }
+        expect(piJsonHash(value, () => piStringify(value))).toBe(hash(piStringify(value)));
+    }
+    console.log(`excluded fingerprint differential: ${samples.length} values per serializer`);
+});
+
+test("part memo catches in-place edits, alias changes, key order and accessor values", () => {
+    const memo = new TailHygieneJsonMemo();
+    let calls = 0;
+    const get = (value: unknown): string => {
+        memo.beginPass();
+        return memo.get("part", value, () => {
+            calls++;
+            return stableStringify(value);
+        });
+    };
+    const shared = { value: "first" };
+    const value = { a: shared, b: shared };
+    expect(get(value)).toBe(get(structuredClone(value)));
+    expect(calls).toBe(1);
+    shared.value = "other";
+    expect(get(value)).toContain("other");
+    expect(calls).toBe(2);
+    value.b = { value: "other" };
+    expect(get(value)).not.toContain("Circular");
+    expect(calls).toBe(3);
+    expect(get({ b: value.b, a: value.a })).toBe(get(value));
+    expect(calls).toBe(5);
+    let changing = 0;
+    const accessor = {
+        get value() {
+            return ++changing;
+        },
+    };
+    expect(get(accessor)).not.toBe(get(accessor));
+    expect(calls).toBe(7);
+});

package/src/shared/tail-hygiene-json.ts

@@ -0,0 +1,217 @@
+import { jsonHashSink } from "./stable-json";
+
+const MAX_MEMO_BYTES = 64 * 1024 * 1024;
+const MAX_MEMO_ENTRIES = 10_000;
+
+/**
+ * A bounded, process-local memo for individual parts and selected tool fields.
+ * Detached snapshots catch in-place host edits; reference equality alone cannot.
+ * Key collisions between sessions only evict entries, never imply equality.
+ */
+export class TailHygieneJsonMemo {
+    private entries = new Map<string, { snapshot: unknown; result: string; bytes: number }>();
+    private bytes = 0;
+    private passText = new WeakMap<object, string>();
+    private passHash = new WeakMap<object, string>();
+
+    beginPass(): void {
+        this.passText = new WeakMap();
+        this.passHash = new WeakMap();
+    }
+
+    get(key: string, value: unknown, compute: () => string, fingerprint = false): string {
+        const pass = fingerprint ? this.passHash : this.passText;
+        const object = value !== null && typeof value === "object" ? value : undefined;
+        const local = object ? pass.get(object) : undefined;
+        if (local !== undefined) return local;
+        const previous = this.entries.get(key);
+        if (previous && sameJson(previous.snapshot, value)) {
+            if (object) pass.set(object, previous.result);
+            return previous.result;
+        }
+        const result = compute();
+        if (previous) {
+            this.bytes -= previous.bytes;
+            this.entries.delete(key);
+        }
+        try {
+            const copy = copyJson(value);
+            const bytes = copy.bytes + (key.length + result.length) * 2;
+            if (bytes <= MAX_MEMO_BYTES) {
+                this.entries.set(key, { snapshot: copy.value, result, bytes });
+                this.bytes += bytes;
+                if (object) pass.set(object, result);
+            }
+        } catch {
+            // Accessors and exotic objects retain their original serialization behavior.
+        }
+        while (this.bytes > MAX_MEMO_BYTES || this.entries.size > MAX_MEMO_ENTRIES) {
+            const oldest = this.entries.entries().next().value;
+            if (!oldest) break;
+            this.bytes -= oldest[1].bytes;
+            this.entries.delete(oldest[0]);
+        }
+        return result;
+    }
+}
+
+function copyJson(value: unknown): { value: unknown; bytes: number } {
+    const seen = new Map<object, unknown>();
+    let bytes = 0;
+    const copy = (current: unknown): unknown => {
+        bytes += 16;
+        if (typeof current === "string") bytes += current.length * 2;
+        if (bytes > MAX_MEMO_BYTES) throw new Error("memo capacity");
+        if (current === null || typeof current !== "object") {
+            if (["function", "symbol", "bigint"].includes(typeof current))
+                throw new Error("exotic");
+            return current;
+        }
+        if (seen.has(current)) return seen.get(current);
+        const prototype = Object.getPrototypeOf(current);
+        if (!Array.isArray(current) && prototype !== Object.prototype && prototype !== null)
+            throw new Error("exotic");
+        const result = Array.isArray(current)
+            ? new Array(current.length)
+            : Object.create(prototype);
+        seen.set(current, result);
+        for (const key of Object.keys(current)) {
+            const descriptor = Object.getOwnPropertyDescriptor(current, key);
+            if (!descriptor || !("value" in descriptor)) throw new Error("accessor");
+            bytes += key.length * 2 + 16;
+            if (key === "__proto__") {
+                Object.defineProperty(result, key, {
+                    value: copy(descriptor.value),
+                    enumerable: true,
+                    writable: true,
+                    configurable: true,
+                });
+            } else result[key] = copy(descriptor.value);
+        }
+        return result;
+    };
+    return { value: copy(value), bytes };
+}
+
+function sameJson(before: unknown, after: unknown): boolean {
+    const forward = new Map<object, object>();
+    const reverse = new Set<object>();
+    const same = (left: unknown, right: unknown): boolean => {
+        if (
+            left === null ||
+            right === null ||
+            typeof left !== "object" ||
+            typeof right !== "object"
+        )
+            return Object.is(left, right);
+        if (forward.has(left)) return forward.get(left) === right;
+        if (reverse.has(right) || Object.getPrototypeOf(left) !== Object.getPrototypeOf(right))
+            return false;
+        forward.set(left, right);
+        reverse.add(right);
+        if (Array.isArray(left) && (!Array.isArray(right) || left.length !== right.length))
+            return false;
+        const keys = Object.keys(left);
+        const otherKeys = Object.keys(right);
+        if (keys.length !== otherKeys.length) return false;
+        for (let index = 0; index < keys.length; index++) {
+            const key = keys[index];
+            // Pi sorts with localeCompare, which can tie distinct Unicode spellings.
+            // Preserve insertion order too, because a tied sort keeps that order.
+            if (key !== otherKeys[index]) return false;
+            const descriptor = Object.getOwnPropertyDescriptor(right, key);
+            if (
+                !descriptor ||
+                !("value" in descriptor) ||
+                !same((left as Record<string, unknown>)[key], descriptor.value)
+            )
+                return false;
+        }
+        return true;
+    };
+    return same(before, after);
+}
+
+/**
+ * Fingerprint excluded Pi content without retaining its whole JSON string.
+ * Match Pi's native JSON replacer: localeCompare key order, omitted undefined
+ * object fields, null array holes, and a marker for repeated non-array objects.
+ * Unsupported objects and array cycles use the original serializer; serialization
+ * errors produce the fingerprint of an empty string, as they did before.
+ */
+export function piJsonHash(value: unknown, fallback: () => string): string {
+    const sink = jsonHashSink("excluded\0");
+    try {
+        const seen = new Set<object>();
+        const arrays = new Set<object>();
+        const write = (current: unknown): void => {
+            if (current === null || typeof current !== "object") {
+                if (["function", "symbol", "bigint"].includes(typeof current))
+                    throw new Error("exotic");
+                sink.write(JSON.stringify(current) ?? "");
+            } else if (Array.isArray(current)) {
+                if (
+                    Object.getPrototypeOf(current) !== Array.prototype ||
+                    Object.hasOwn(current, "toJSON")
+                )
+                    throw new Error("exotic array");
+                if (arrays.has(current)) throw new Error("array cycle");
+                arrays.add(current);
+                sink.write("[");
+                for (let index = 0; index < current.length; index++) {
+                    if (index) sink.write(",");
+                    const descriptor = Object.getOwnPropertyDescriptor(current, index);
+                    if (descriptor && !("value" in descriptor)) throw new Error("accessor");
+                    if (!descriptor && index in current) throw new Error("inherited array element");
+                    write(descriptor?.value === undefined ? null : descriptor.value);
+                }
+                sink.write("]");
+                arrays.delete(current);
+            } else if (seen.has(current)) {
+                sink.write('"[Circular]"');
+            } else {
+                const prototype = Object.getPrototypeOf(current);
+                if (prototype !== Object.prototype && prototype !== null) throw new Error("exotic");
+                seen.add(current);
+                const entries = Object.keys(current).map((key): [string, unknown] => {
+                    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                    if (!descriptor || !("value" in descriptor)) throw new Error("accessor");
+                    return [key, descriptor.value];
+                });
+                const sorted = Object.fromEntries(entries.sort(([a], [b]) => a.localeCompare(b)));
+                if (
+                    entries.length <= 16 &&
+                    entries.every(
+                        ([key, child]) =>
+                            key.length <= 4096 &&
+                            (child === null ||
+                                child === undefined ||
+                                typeof child === "number" ||
+                                typeof child === "boolean" ||
+                                (typeof child === "string" && child.length <= 4096)),
+                    )
+                ) {
+                    sink.write(JSON.stringify(sorted));
+                    return;
+                }
+                sink.write("{");
+                let first = true;
+                for (const [key, child] of Object.entries(sorted)) {
+                    if (child === undefined) continue;
+                    if (!first) sink.write(",");
+                    first = false;
+                    sink.write(JSON.stringify(key));
+                    sink.write(":");
+                    write(child);
+                }
+                sink.write("}");
+            }
+        };
+        write(value);
+        return sink.digest();
+    } catch {
+        const failed = jsonHashSink("excluded\0");
+        failed.write(fallback());
+        return failed.digest();
+    }
+}

package/src/shared/user-facing-codes.ts

@@ -18,8 +18,8 @@ export const USER_FACING_FAILURES = {
     history_boundary_unresolved: {
         code: "MC-H04",
         sentence:
-            "This request was not sent: the message that marks where this session's history summary ends is missing from the OpenCode store, and without it the request is larger than the model's context window.",
-        action: "Run /mmc-recomp to rebuild the history summary.",
+            "This request was not sent: Magic Context could not safely place the history summary boundary in the loaded conversation, and the untrimmed request is larger than the model's context window.",
+        action: "Reopen this session in its current project directory, then run /mmc-recomp to rebuild the history summary. A model with a larger context window can also help.",
     },
     history_over_window_unmanaged: {
         code: "MC-H06",

package/dist/model-resolution-wazv26n0.js

@@ -1,6 +0,0 @@
-import {
-  resolveHistorianModel2
-} from "./index-z2g20msd.js";
-export {
-  resolveHistorianModel2 as resolveHistorianModel
-};