@cortexkit/opencode-magic-context 0.46.1 → 0.48.0

package/src/shared/stable-json-linear.test.ts

@@ -0,0 +1,109 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, it } from "bun:test";
+import { stableStringify } from "./stable-json";
+
+/** stableStringify as it was before it collected pieces: joins at every level. */
+function frozenStableStringify(value: unknown, seen = new WeakSet<object>()): string {
+    if (value === undefined) return "undefined";
+    if (value === null || typeof value !== "object") return JSON.stringify(value) ?? String(value);
+    if (seen.has(value)) return '"[Circular]"';
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => frozenStableStringify(item, seen)).join(",")}]`;
+    }
+    const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    });
+    return `{${entries
+        .map(([key, child]) => `${JSON.stringify(key)}:${frozenStableStringify(child, seen)}`)
+        .join(",")}}`;
+}
+
+function rng(seed: number): () => number {
+    let state = seed >>> 0 || 1;
+    return () => {
+        state ^= state << 13;
+        state >>>= 0;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        state >>>= 0;
+        return state / 0x100000000;
+    };
+}
+
+function randomValue(random: () => number, depth: number, shared: object[]): unknown {
+    const roll = random();
+    if (depth > 4 || roll < 0.35) {
+        const leaves: unknown[] = [
+            "plain",
+            'quote " and \\ backslash',
+            "ünï 日本 😀 \u2028",
+            0,
+            -0,
+            1.5,
+            Number.NaN,
+            Number.POSITIVE_INFINITY,
+            true,
+            false,
+            null,
+            undefined,
+            () => 1,
+            Symbol("s"),
+        ];
+        return leaves[Math.floor(random() * leaves.length)];
+    }
+    if (roll < 0.45 && shared.length > 0) return shared[Math.floor(random() * shared.length)];
+    if (roll < 0.7) {
+        const array: unknown[] = [];
+        const length = Math.floor(random() * 5);
+        for (let index = 0; index < length; index += 1) {
+            if (random() < 0.15) continue; // leaves a hole
+            array[index] = randomValue(random, depth + 1, shared);
+        }
+        array.length = length;
+        if (random() < 0.2) shared.push(array);
+        return array;
+    }
+    const object: Record<string, unknown> = {};
+    for (let index = Math.floor(random() * 5); index > 0; index -= 1) {
+        const key = ["b", "a", "10", "2", "é", "Z", "key with space"][
+            Math.floor(random() * 7)
+        ] as string;
+        object[key] = randomValue(random, depth + 1, shared);
+    }
+    if (random() < 0.2) shared.push(object);
+    if (random() < 0.1) object.self = object;
+    return object;
+}
+
+describe("stableStringify", () => {
+    it("writes exactly what it wrote when it joined at every level", () => {
+        const random = rng(653);
+        let circular = 0;
+        let holes = 0;
+        for (let sample = 0; sample < 2_000; sample += 1) {
+            const value = randomValue(random, 0, []);
+            const text = stableStringify(value);
+            expect(text).toBe(frozenStableStringify(value));
+            if (text.includes('"[Circular]"')) circular += 1;
+            if (/\[,|,,|,\]/.test(text)) holes += 1;
+        }
+        // Shared and cyclic references and array holes were among the samples.
+        expect(circular).toBeGreaterThan(50);
+        expect(holes).toBeGreaterThan(50);
+    });
+
+    it("copies a deeply nested value once, not once per level", () => {
+        // 3,000 levels around a 2 MB string: joining at every level copied about
+        // 6 GB of text (over a second); one copy takes a few milliseconds.
+        let node: unknown = { body: "x".repeat(2_000_000) };
+        for (let depth = 0; depth < 3_000; depth += 1) node = { child: node, depth };
+        const started = performance.now();
+        const text = stableStringify(node);
+        expect(text.length).toBeGreaterThan(2_000_000);
+        expect(performance.now() - started).toBeLessThan(300);
+    }, 30_000);
+});

package/src/shared/stable-json.ts

@@ -18,12 +18,38 @@
  * signing), build a separate utility — do NOT widen this contract.
  */
 export function stableStringify(value: unknown, seen = new WeakSet<object>()): string {
-    if (value === undefined) return "undefined";
-    if (value === null || typeof value !== "object") return JSON.stringify(value) ?? String(value);
-    if (seen.has(value)) return '"[Circular]"';
+    // Collect pieces and join once. Joining at every level copied each nested
+    // 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);
+    return pieces.join("");
+}
+
+function writeStable(value: unknown, seen: WeakSet<object>, pieces: string[]): void {
+    if (value === undefined) {
+        pieces.push("undefined");
+        return;
+    }
+    if (value === null || typeof value !== "object") {
+        pieces.push(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]"');
+        return;
+    }
     seen.add(value);
     if (Array.isArray(value)) {
-        return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+        pieces.push("[");
+        for (let index = 0; index < value.length; index += 1) {
+            if (index > 0) pieces.push(",");
+            // A hole writes nothing between its commas, as joining a mapped array did.
+            if (index in value) writeStable(value[index], seen, pieces);
+        }
+        pieces.push("]");
+        return;
     }
     // Code-point sort (NOT localeCompare). Stable across runtimes/locales.
     const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => {
@@ -31,7 +57,11 @@ export function stableStringify(value: unknown, seen = new WeakSet<object>()): s
         if (a > b) return 1;
         return 0;
     });
-    return `{${entries
-        .map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`)
-        .join(",")}}`;
+    pieces.push("{");
+    entries.forEach(([key, child], index) => {
+        if (index > 0) pieces.push(",");
+        pieces.push(JSON.stringify(key), ":");
+        writeStable(child, seen, pieces);
+    });
+    pieces.push("}");
 }

package/src/shared/status-view.test.ts

@@ -118,7 +118,12 @@ describe("status view model", () => {
         expect(rowLabels("Tags")).toEqual(["Active", "Dropped", "Total"]);
         expect(rowLabels("Reductions")).toEqual(["Execute threshold", "Last reduce anchor"]);
         expect(rowLabels("Pending Queue")).toEqual(["Drops", "Marker"]);
-        expect(rowLabels("Context Details")).toEqual(["Protected tags", "Subagent"]);
+        expect(rowLabels("Context Details")).toEqual([
+            "Protected tags",
+            "Subagent",
+            "Denominator",
+            "Window source",
+        ]);
         expect(rowLabels("Cache TTL")).toEqual([
             "Configured",
             "Last response",

package/src/shared/status-view.ts

@@ -31,7 +31,11 @@ import {
     type UserFacingFailureKey,
     userFacingFailureCode,
 } from "./user-facing-codes";
-import { formatWindowDerivationLine, type WindowGeometryResult } from "./window-geometry";
+import {
+    formatWindowDerivationLine,
+    formatWindowSource,
+    type WindowGeometryResult,
+} from "./window-geometry";
 
 /** Theme-independent colour role; each host maps these onto its own palette. */
 export type StatusTone = "accent" | "text" | "muted" | "warning" | "error";
@@ -656,6 +660,16 @@ function statusSections(source: StatusViewSource, now: number): StatusSection[]
                     tone: "muted",
                 },
                 { label: "Subagent", value: source.isSubagent ? "yes" : "no", tone: "muted" },
+                {
+                    label: "Denominator",
+                    value: `${Math.round(source.contextLimit)} tokens`,
+                    tone: "muted",
+                },
+                {
+                    label: "Window source",
+                    value: formatWindowSource(source.windowGeometry),
+                    tone: "muted",
+                },
             ],
         },
         { title: "Cache TTL", labelWidth: 14, rows: cacheRows(source, now) },

package/src/shared/tag-transcript.ts

@@ -1157,6 +1157,10 @@ function buildAggregateTarget(
     };
 
     return {
+        mutationParts: occurrences.map((occ) => ({
+            message: { info: occ.message.info, parts: [] },
+            part: occ.part,
+        })),
         measureReclaim(skeleton) {
             let beforeTools = 0;
             let afterTools = 0;
@@ -1319,6 +1323,7 @@ function buildTextTarget(
     textPrefix: string,
 ): TagTarget {
     return {
+        mutationParts: [{ message: { info: message.info, parts: [] }, part }],
         textPrefix,
         setContent(content: string): boolean {
             return part.setText(content);
@@ -1351,6 +1356,7 @@ function buildToolTarget(
     tagId: number,
 ): TagTarget {
     return {
+        mutationParts: [{ message: { info: message.info, parts: [] }, part }],
         setContent(content: string): boolean {
             return setToolContentOrText(part, content);
         },

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

@@ -245,12 +245,8 @@ export const USER_FACING_FAILURES = {
         sentence: "Magic Context has no context.db.",
         action: "Run `npx @cortexkit/magic-context doctor store init`, then restart ck-mc.",
     },
-    checkout_claim_held_elsewhere: {
-        code: "MC-C16",
-        sentence:
-            "This request was not sent: this agent is checked out on another machine, so Magic Context will not work on its sessions here.",
-        action: "Move the agent back to this machine, then send your message again.",
-    },
+    // MC-C16 is retired: released builds showed it when a turn was refused because
+    // another machine held the session's agent. Do not reuse it for a new failure.
     single_store_migration_required: {
         code: "MC-C14",
         sentence: "Magic Context's Rust mode needs a one-time migration of its store.",

package/src/shared/window-geometry.ts

@@ -89,6 +89,8 @@ export interface WindowDerivation {
     geometry: WindowGeometry;
     windowSource: WindowLimitSource;
     absoluteWall: number;
+    /** Accepted provider input used to raise the usable denominator above metadata. */
+    provenInputTokens?: number;
 }
 
 export interface WindowGeometryResult {
@@ -691,6 +693,7 @@ export function applyProvenInputFloor(
                 absoluteWall: trustedAbsoluteWall
                     ? geometry.derivation.absoluteWall
                     : Math.max(geometry.derivation.absoluteWall, provenInputTokens),
+                provenInputTokens,
             },
         },
     };
@@ -715,6 +718,13 @@ export function formatWindowDerivationLine(
     return `${formatCompactTokens(inputTokens)} / ${formatCompactTokens(result.usableSoft)} usable · window ${formatCompactTokens(result.derivation.window)} · ${formatCompactTokens(result.derivation.reserve)} ${reserveLabel}`;
 }
 
+/** Distinguish metadata from a denominator raised by an accepted input measurement. */
+export function formatWindowSource(result: WindowGeometryResult | undefined): string {
+    return result?.derivation.provenInputTokens
+        ? `provider-measured floor (${result.derivation.windowSource})`
+        : (result?.derivation.windowSource ?? "unknown");
+}
+
 export function formatCompactTokens(value: number): string {
     if (Math.abs(value) >= 1_000_000) {
         return `${(value / 1_000_000).toFixed(1).replace(/\.0$/, "")}m`;

package/src/shared/write-transaction-attribution.test.ts

@@ -87,7 +87,7 @@ const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: stri
     },
     {
         path: "packages/pi-plugin/src/context-handler.ts",
-        sites: ["pi_compaction_queue"],
+        sites: ["pi_fallback_adoption"],
     },
 ];
 
@@ -149,7 +149,7 @@ const newlyCoveredSites = [
     "pi_materialize_cache",
     "pi_soft_refresh_cache",
     "pi_historian_publish",
-    "pi_compaction_queue",
+    "pi_fallback_adoption",
     "note_nudge_trigger",
     "user_memory_candidate_insert",
 ] as const;

package/src/v2/tui/host-contract.test.ts

@@ -1,10 +1,12 @@
-import { afterEach, expect, spyOn, test } from "bun:test";
+import { afterEach, expect, test } from "bun:test";
 import { rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { resolve } from "node:path";
 import { Host } from "@opencode/plugin/host";
-import * as logger from "../../shared/logger";
+import type { MagicContextRpcServer } from "../../shared/rpc-server";
 import { createTestTempDirFromPath } from "../../shared/test-temp-dir";
+import { registerV2Commands } from "../hooks/commands";
+import type { V2CommandDomain } from "../hooks/types";
 import { setupWithJsx } from "./index";
 import type { V2SidebarState, V2SlotClaim, V2TuiContext } from "./types";
 
@@ -110,7 +112,7 @@ function v1Api(directory: string) {
     };
 }
 
-test("GA 2.0.5 resolves ./tui and executes the union setup contract", async () => {
+test("GA 2.0.5 registers each /ctx-* command once on the server, not the TUI keymap", async () => {
     const packageRoot = resolve(import.meta.dir, "../../..");
     const entrypoints = Host.resolve({
         name: "@cortexkit/opencode-magic-context",
@@ -125,76 +127,48 @@ test("GA 2.0.5 resolves ./tui and executes the union setup contract", async () =
         };
     };
     expect(typeof loaded.default.setup).toBe("function");
-    const fixture = v2Context();
-    const cleanup = await setupWithJsx(fixture.context, (type, props) => ({ type, props }));
-    expect(fixture.claims.map((claim) => claim.append)).toEqual(["sidebar.content"]);
-    const sidebarClaim = fixture.claims[0]!;
-    if (sidebarClaim.append !== "sidebar.content") throw new Error("expected the sidebar claim");
-    expect(sidebarClaim.render({ sessionID: "ses-v2-tui" })).toEqual({
-        type: "text",
-        props: { children: expect.stringContaining("Magic Context") },
-    });
-    expect(fixture.layers[0]!.commands.map((command) => command.slash.name)).toEqual([
-        "ctx-status",
-        "ctx-recomp",
-        "ctx-dream",
-        "ctx-flush",
-        "ctx-embed",
-        "ctx-wrapup",
-    ]);
-    cleanup();
-});
-
-test("GA 2.0.5 registers the keymap layer from the app slot when setup runs outside the provider", async () => {
-    const fixture = v2Context();
-    let providerAvailable = false;
-    Object.assign(fixture.context.keymap, {
-        layer: (input: () => unknown) => {
-            if (!providerAvailable) throw new Error("Keymap.Provider is missing");
-            fixture.layers.push(input() as never);
+    const serverCommands: string[] = [];
+    const commandDomain: V2CommandDomain = {
+        async transform(callback) {
+            callback({ add: (definition) => serverCommands.push(definition.name) });
         },
+        async reload() {},
+    };
+    const serverRegistered = await registerV2Commands({
+        command: commandDomain,
+        rpc: { dispatch: async () => ({}) } as unknown as MagicContextRpcServer,
+        directory: process.cwd(),
+        compactionEnabled: true,
     });
-    const cleanup = await setupWithJsx(fixture.context, (type, props) => ({ type, props }));
-    expect(fixture.claims.map((claim) => claim.append)).toEqual(["sidebar.content", "app"]);
-    expect(fixture.layers).toHaveLength(0);
+    expect(serverRegistered).toBe(true);
 
-    // The app slot render executes inside the component tree, where the provider resolves.
-    providerAvailable = true;
-    const appClaim = fixture.claims.find((claim) => claim.append === "app");
-    if (appClaim?.append !== "app") throw new Error("expected the app slot claim");
-    appClaim.render({});
-    expect(
-        fixture.layers.map((layer) => layer.commands.map((command) => command.slash.name)),
-    ).toEqual([["ctx-status", "ctx-recomp", "ctx-dream", "ctx-flush", "ctx-embed", "ctx-wrapup"]]);
-    // Repeated renders must not stack duplicate layers.
-    appClaim.render({});
-    expect(fixture.layers).toHaveLength(1);
-    cleanup();
-});
-
-test("GA 2.0.5 keeps the sidebar when the app-slot keymap registration also fails", async () => {
     const fixture = v2Context();
-    Object.assign(fixture.context.keymap, {
-        layer: () => {
-            throw new Error("Keymap.Provider is missing");
-        },
-    });
-    // The gap is recorded in the plugin log; the TUI host drops console output.
-    const logged = spyOn(logger, "log");
+    const cleanup = await setupWithJsx(fixture.context, (type, props) => ({ type, props }));
     try {
-        const cleanup = await setupWithJsx(fixture.context, (type, props) => ({ type, props }));
-        expect(fixture.claims.map((claim) => claim.append)).toEqual(["sidebar.content", "app"]);
-        const appClaim = fixture.claims.find((claim) => claim.append === "app");
-        if (appClaim?.append !== "app") throw new Error("expected the app slot claim");
-        appClaim.render({});
-        appClaim.render({});
-        expect(fixture.layers).toHaveLength(0);
-        expect(
-            logged.mock.calls.filter(([line]) => line.includes("keymap.layer is unavailable")),
-        ).toHaveLength(1);
-        cleanup();
+        expect(fixture.claims.map((claim) => claim.append)).toEqual(["sidebar.content"]);
+        const sidebarClaim = fixture.claims[0]!;
+        if (sidebarClaim.append !== "sidebar.content")
+            throw new Error("expected the sidebar claim");
+        expect(sidebarClaim.render({ sessionID: "ses-v2-tui" })).toEqual({
+            type: "text",
+            props: { children: expect.stringContaining("Magic Context") },
+        });
+        const tuiCommands = fixture.layers.flatMap((layer) =>
+            layer.commands.map((command) => command.slash.name),
+        );
+        const allRegistrations = [...serverCommands, ...tuiCommands].sort();
+        const expectedCommands = [
+            "ctx-dream",
+            "ctx-embed",
+            "ctx-flush",
+            "ctx-recomp",
+            "ctx-status",
+            "ctx-wrapup",
+        ];
+        expect(allRegistrations).toEqual(expectedCommands);
+        expect(new Set(allRegistrations).size).toBe(expectedCommands.length);
     } finally {
-        logged.mockRestore();
+        cleanup();
     }
 });