@cortexkit/opencode-magic-context 0.44.3 → 0.45.0

package/src/shared/user-answer.ts

@@ -0,0 +1,17 @@
+import { isRecord } from "./record-type-guard";
+
+/** Host-owned answer metadata, independent of the tool's registered name. */
+export function hasUserAnswerMetadata(value: unknown): boolean {
+    if (!isRecord(value)) return false;
+    if (value.userAnswer === true) return true;
+    if (Array.isArray(value.answers)) return true;
+    if (typeof value.answer === "string") return true;
+    if (Array.isArray(value.selectedOptions) || typeof value.customInput === "string") return true;
+    return Array.isArray(value.results) && value.results.some(hasUserAnswerMetadata);
+}
+
+export function toolPartHasUserAnswer(part: unknown): boolean {
+    if (!isRecord(part)) return false;
+    const state = isRecord(part.state) ? part.state : undefined;
+    return hasUserAnswerMetadata(state?.metadata) || hasUserAnswerMetadata(part.details);
+}

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

@@ -1,5 +1,6 @@
 import type { EmbeddingFailureClass } from "../features/magic-context/memory/embedding-failure";
 import type { PromptFailureClass } from "./model-suggestion-retry";
+import { sanitizeDiagnosticText } from "./redaction";
 
 export const USER_FACING_FAILURES = {
     historian_unavailable: {
@@ -7,17 +8,36 @@ export const USER_FACING_FAILURES = {
         sentence: "History compression could not finish this turn.",
         action: "It will retry automatically.",
     },
-    hidden_cleanup_unbound: {
-        code: "MC-H02",
-        sentence: "Some finished background sessions could not be removed from this host.",
-        action: "They are removed automatically the next time Magic Context runs inside a registered OpenCode service.",
-    },
     historian_saved_history_misaligned: {
         code: "MC-H03",
         sentence:
             "History compression is paused because this session's saved summaries no longer line up with its messages.",
         action: "Run /ctx-recomp to rebuild them.",
     },
+    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 /ctx-recomp to rebuild the history summary.",
+    },
+    history_over_window_unmanaged: {
+        code: "MC-H06",
+        sentence:
+            "This request was not sent: this session's history is larger than the model's context window, and Magic Context does not have a summary of it yet to send in its place.",
+        action: "Send your message again once history compression has caught up, or switch to a model with a larger context window.",
+    },
+    frozen_history_over_window: {
+        code: "MC-H07",
+        sentence:
+            "This request was not sent: the conversation is larger than the context window the provider reported, and the compressed history Magic Context has ready does not fit either.",
+        action: "Run /ctx-flush to compress it now, then send your message again.",
+    },
+    historian_window_too_small: {
+        code: "MC-H05",
+        sentence:
+            "History compression is paused because the history model's context window is too small for its instructions.",
+        action: "Set historian.model in magic-context.jsonc to a model with a larger context window.",
+    },
     recomp_unavailable: {
         code: "MC-R01",
         sentence: "History compression could not be rebuilt.",
@@ -33,6 +53,11 @@ export const USER_FACING_FAILURES = {
         sentence: "Memory maintenance could not reach its model.",
         action: "Check the model connection, then run /ctx-dream again.",
     },
+    dream_local_refusal: {
+        code: "MC-D12",
+        sentence: "Memory maintenance was refused before reaching the model.",
+        action: "Check the hidden-request diagnostic in the Magic Context log before retrying.",
+    },
     dream_step_limit: {
         code: "MC-D10",
         sentence: "Memory maintenance stopped at its hidden agent step limit.",
@@ -149,6 +174,12 @@ export const USER_FACING_FAILURES = {
         sentence: "The last context update did not finish.",
         action: "Send another message to retry.",
     },
+    transform_pass_degraded: {
+        code: "MC-S06",
+        sentence:
+            "This request was not sent: Magic Context could not finish preparing it, and without that preparation it could be far larger than the previous request.",
+        action: "Send your message again.",
+    },
     configuration_warning: {
         code: "MC-S03",
         sentence: "Some configuration settings could not be applied.",
@@ -209,6 +240,16 @@ export const USER_FACING_FAILURES = {
         sentence: "Magic Context is temporarily unavailable.",
         action: "Retry in a moment.",
     },
+    context_db_missing: {
+        code: "MC-C15",
+        sentence: "Magic Context has no context.db.",
+        action: "Run `npx @cortexkit/magic-context doctor store init`, then restart ck-mc.",
+    },
+    single_store_migration_required: {
+        code: "MC-C14",
+        sentence: "Magic Context's Rust mode needs a one-time migration of its store.",
+        action: "Quit OpenCode and every ck-mc process, then run `magic-context doctor single-store migrate`.",
+    },
     store_ahead_of_binary: {
         code: "MC-C13",
         sentence:
@@ -289,6 +330,7 @@ export function capabilityRefusalCode(capability: CapabilityRefusal): string {
 const DREAM_FAILURE_KEYS = {
     provider_timeout: "dream_provider_timeout",
     provider_error: "dream_provider_error",
+    local_refusal: "dream_local_refusal",
     step_limit: "dream_step_limit",
     token_budget: "dream_token_budget",
     empty_completion: "dream_empty_completion",
@@ -315,8 +357,12 @@ const EMBEDDING_FAILURE_KEYS = {
 export function renderDreamFailure(
     failureClass: PromptFailureClass,
     style: UserFacingTextStyle = "markdown",
+    refusalReason?: string | null,
 ): string {
-    return renderUserFacingFailure(DREAM_FAILURE_KEYS[failureClass], style);
+    const rendered = renderUserFacingFailure(DREAM_FAILURE_KEYS[failureClass], style);
+    return failureClass === "local_refusal" && refusalReason
+        ? `${rendered} Reason: ${sanitizeDiagnosticText(refusalReason).slice(0, 500)}`
+        : rendered;
 }
 
 export function dreamFailureCode(failureClass: PromptFailureClass): string {

package/src/shared/window-geometry.test.ts

@@ -1,8 +1,9 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { resolveLimit, resolveOutputReserve } from "./models-dev-cache";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 import {
     applyProvenInputFloor,
     deriveWindowGeometry,
@@ -160,7 +161,7 @@ describe("Fusiform overlay v1", () => {
     });
 
     test("a missing file is silent and a bad file logs one summary", () => {
-        const dir = mkdtempSync(join(tmpdir(), "window-overlay-test-"));
+        const dir = createTestTempDirFromPath(join(tmpdir(), "window-overlay-test-"));
         tempDirs.push(dir);
         const logs: string[] = [];
         expect(

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

@@ -1,7 +1,8 @@
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { readFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
+import { createTestTempDirFromPath } from "./test-temp-dir";
 
 const repoRoot = resolve(import.meta.dir, "../../../../");
 const beginImmediate = /\b(?:[A-Za-z_$][\w$]*\.)?exec\("BEGIN IMMEDIATE"\)/g;
@@ -32,10 +33,7 @@ const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: stri
             "storage_meta_wrapup_release",
         ],
     },
-    {
-        path: "packages/plugin/src/features/magic-context/context-authority.ts",
-        sites: ["authority_marker_capture", "authority_capture_check"],
-    },
+
     {
         path: "packages/plugin/src/features/magic-context/compartment-storage.ts",
         sites: ["compartment_state_replace", "recomp_staging_promote"],
@@ -53,7 +51,7 @@ const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: stri
         // directly), so it reports through the injected reporter instead.
         path: "packages/plugin/src/shared/sqlite.ts",
         sites: ["async_acquisition_dynamic_site", "privileged_writer"],
-        reporterCalls: ["console.warn(", "reportSlowPrivilegedWrite?.("],
+        reporterCalls: ["reportSqliteDiagnostic(", "reportSlowPrivilegedWrite?.("],
     },
     {
         path: "packages/plugin/src/features/magic-context/git-commits/sweep-coordinator.ts",
@@ -94,6 +92,10 @@ const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: stri
 ];
 
 const nonBeginCoveredSites: Array<{ path: string; site: string }> = [
+    {
+        path: "packages/plugin/src/hooks/magic-context/lkg-persist.ts",
+        site: "lkg_stale_gc",
+    },
     {
         path: "packages/plugin/src/hooks/magic-context/compartment-runner-incremental.ts",
         site: "historian-publish",
@@ -180,7 +182,9 @@ function assertCoveredBeginImmediate(
 
 describe("write transaction attribution fences", () => {
     beforeAll(async () => {
-        scenarioRoot = mkdtempSync(join(tmpdir(), "magic-context-write-attribution-"));
+        scenarioRoot = createTestTempDirFromPath(
+            join(tmpdir(), "magic-context-write-attribution-"),
+        );
         scenarioLogPath = join(scenarioRoot, "transactions.log");
         const scenario = `
             const timing = await import(${JSON.stringify(new URL("./write-transaction-timing.ts", import.meta.url).href)});

package/src/shared/write-transaction-hold-clock.test.ts

@@ -0,0 +1,160 @@
+import { expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import ts from "typescript";
+
+function visit(node: ts.Node, callback: (node: ts.Node) => void): void {
+    callback(node);
+    ts.forEachChild(node, (child) => visit(child, callback));
+}
+function acquires(statement: ts.Statement): boolean {
+    const direct = (expression: ts.Expression): boolean => {
+        if (!ts.isCallExpression(expression)) return false;
+        if (
+            ts.isPropertyAccessExpression(expression.expression) &&
+            expression.expression.name.text === "exec"
+        ) {
+            const sql = expression.arguments[0];
+            return (
+                !!sql && ts.isStringLiteral(sql) && /^BEGIN (?:IMMEDIATE|EXCLUSIVE)$/.test(sql.text)
+            );
+        }
+        if (
+            ["withSqliteBackgroundWriter", "withoutSqliteTransformPass"].includes(
+                expression.expression.getText(),
+            )
+        ) {
+            const callback = expression.arguments[0];
+            return (
+                !!callback &&
+                ts.isArrowFunction(callback) &&
+                !ts.isBlock(callback.body) &&
+                direct(callback.body)
+            );
+        }
+        return false;
+    };
+    if (ts.isExpressionStatement(statement)) return direct(statement.expression);
+    if (ts.isTryStatement(statement)) {
+        const last = statement.catchClause?.block.statements.at(-1);
+        return (
+            !!last &&
+            (ts.isReturnStatement(last) || ts.isThrowStatement(last)) &&
+            statement.tryBlock.statements.some(acquires)
+        );
+    }
+    return false;
+}
+function afterAdmission(clock: ts.Node): boolean {
+    for (let node: ts.Node | undefined = clock; node; node = node.parent) {
+        if (ts.isBlock(node.parent) && ts.isStatement(node)) {
+            const preceding = node.parent.statements.slice(0, node.parent.statements.indexOf(node));
+            if (preceding.some(acquires)) return true;
+        }
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            const call = node.parent;
+            if (
+                ts.isCallExpression(call) &&
+                ts.isPropertyAccessExpression(call.expression) &&
+                call.expression.name.text === "transaction"
+            ) {
+                const mode = call.parent;
+                if (
+                    ts.isPropertyAccessExpression(mode) &&
+                    ["immediate", "exclusive"].includes(mode.name.text)
+                )
+                    return true;
+            }
+            return false;
+        }
+        if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) return false;
+    }
+    return false;
+}
+function violations(text: string, path: string): string[] {
+    const source = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true);
+    const result: string[] = [];
+    visit(source, (node) => {
+        if (!ts.isCallExpression(node) || node.expression.getText() !== "logSlowWriteTransaction")
+            return;
+        const clockName = node.arguments[1]?.getText();
+        let scope: ts.Node = node;
+        while (scope.parent && !ts.isFunctionLike(scope)) scope = scope.parent;
+        const clocks: ts.Node[] = [];
+        let asyncAdmission = false;
+        visit(scope, (candidate) => {
+            const rhs =
+                ts.isVariableDeclaration(candidate) && candidate.name.getText() === clockName
+                    ? candidate.initializer
+                    : ts.isBinaryExpression(candidate) &&
+                        candidate.left.getText() === clockName &&
+                        candidate.operatorToken.kind === ts.SyntaxKind.EqualsToken
+                      ? candidate.right
+                      : undefined;
+            if (!rhs) return;
+            if (rhs.getText().includes("performance.now()")) clocks.push(candidate);
+            if (
+                ts.isAwaitExpression(rhs) &&
+                ts.isCallExpression(rhs.expression) &&
+                rhs.expression.expression.getText() === "beginSqliteWriterAsync"
+            )
+                asyncAdmission = true;
+        });
+        const line = source.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+        if ((!clocks.length && !asyncAdmission) || clocks.some((clock) => !afterAdmission(clock)))
+            result.push(
+                `${path}:${line} ${node.arguments[0]?.getText()} starts its hold clock before writer admission`,
+            );
+    });
+    return result;
+}
+
+test("hold-clock fence distinguishes wait time from transaction callback time", () => {
+    expect(
+        violations(
+            'function f(db) { const clock=performance.now(); db.exec("BEGIN IMMEDIATE"); logSlowWriteTransaction("bad",clock); }',
+            "fixture.ts",
+        ),
+    ).toHaveLength(1);
+    expect(
+        violations(
+            'function f(db) { db.exec("BEGIN IMMEDIATE"); const clock=performance.now(); logSlowWriteTransaction("good",clock); }',
+            "fixture.ts",
+        ),
+    ).toEqual([]);
+    expect(
+        violations(
+            'function f(db) { withoutSqliteTransformPass(()=>withSqliteBackgroundWriter(()=>db.exec("BEGIN IMMEDIATE"))); const clock=performance.now(); logSlowWriteTransaction("good",clock); }',
+            "fixture.ts",
+        ),
+    ).toEqual([]);
+    expect(
+        violations(
+            'function f(db) { let clock=0; db.transaction(()=>{clock=performance.now();}).immediate(); logSlowWriteTransaction("good",clock); }',
+            "fixture.ts",
+        ),
+    ).toEqual([]);
+    expect(
+        violations(
+            'function f(db) { const clock=performance.now(); db.transaction(()=>{}).immediate(); logSlowWriteTransaction("bad",clock); }',
+            "fixture.ts",
+        ),
+    ).toHaveLength(1);
+});
+
+test("every slow-write hold clock starts after writer admission", () => {
+    const root = resolve(import.meta.dir, "../../../../");
+    const failures: string[] = [];
+    let sources = 0;
+    for (const pattern of ["packages/plugin/src/**/*.ts", "packages/pi-plugin/src/**/*.ts"]) {
+        for (const path of new Bun.Glob(pattern).scanSync({ cwd: root })) {
+            if (path.endsWith(".test.ts")) continue;
+            const text = readFileSync(resolve(root, path), "utf8");
+            if (!text.includes("logSlowWriteTransaction(")) continue;
+            sources++;
+            failures.push(...violations(text, path));
+        }
+    }
+    expect(sources).toBeGreaterThan(20);
+    expect(failures).toEqual([]);
+});

package/src/shared/xml-unescape.ts

@@ -0,0 +1,19 @@
+const XML_ENTITY_REGEX = /&(amp|apos|quot|lt|gt);/g;
+const XML_ENTITIES: Readonly<Record<string, string>> = {
+    amp: "&",
+    apos: "'",
+    quot: '"',
+    lt: "<",
+    gt: ">",
+};
+
+/**
+ * Decode the five predefined XML entities in a single left-to-right pass, so
+ * every entity is decoded exactly once. Chained replacements that decode
+ * `&amp;` first would turn the escaped literal `&amp;lt;` into `<` instead of
+ * the text `&lt;`. Unknown entities are left untouched. The Rust historian
+ * parser (`historian_validate::unescape_xml`) must stay identical.
+ */
+export function unescapeXml(s: string): string {
+    return s.replace(XML_ENTITY_REGEX, (entity, name: string) => XML_ENTITIES[name] ?? entity);
+}

package/src/tui/data/context-db.test.ts

@@ -1,9 +1,10 @@
 import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, realpathSync, rmSync, symlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { MagicContextRpcServer } from "../../shared/rpc-server";
 import type { SidebarSnapshot } from "../../shared/rpc-types";
+import { createTestTempDirFromPath } from "../../shared/test-temp-dir";
 import {
     closeRpc,
     getCompartmentCount,
@@ -33,7 +34,7 @@ afterEach(() => {
 });
 
 function makeDataHome(): string {
-    const dir = mkdtempSync(join(tmpdir(), "mc-context-db-"));
+    const dir = createTestTempDirFromPath(join(tmpdir(), "mc-context-db-"));
     tempDirs.push(dir);
     process.env.XDG_DATA_HOME = dir;
     // The shared resolver gives test isolation priority. Keep both values
@@ -120,12 +121,99 @@ describe("TUI context RPC data", () => {
         }));
         initRpcClient(directory);
 
+        // The error reaches the dialog as a named reason, never as a snapshot.
         expect(await loadStatusDetail("ses_rust", directory)).toEqual({
-            ok: false,
-            error: "Rust module status unavailable; canonical session state was not read",
+            state: "unavailable",
+            reason: {
+                kind: "rpc_error",
+                message: "Rust module status unavailable; canonical session state was not read",
+            },
+            versions: null,
+        });
+    });
+
+    test("session calls go to the server of the session's directory, not the startup one", async () => {
+        // The TUI started in the home directory; the session it shows belongs
+        // to a project directory with its own Magic Context server instance.
+        const dataHome = makeDataHome();
+        const home = "/home-startup";
+        const project = "/home-startup/Pictures/project";
+        const homeServer = await startServer(dataHome, home, () => ({
+            sessionId: "ses_project",
+            disabled: true,
+        }));
+        homeServer.handle("status-detail", async () => ({
+            sessionId: "ses_project",
+            disabled: true,
+        }));
+        homeServer.handle("compartment-count", async () => ({ count: 0 }));
+        const projectServer = await startServer(
+            dataHome,
+            project,
+            () => snapshot("ses_project", 400) as unknown as Record<string, unknown>,
+        );
+        projectServer.handle("status-detail", async () => ({ error: "from the project server" }));
+        projectServer.handle("compartment-count", async () => ({ count: 72 }));
+        initRpcClient(home);
+
+        expect((await loadSidebarSnapshot("ses_project", project)).compartmentCount).toBe(2);
+        const status = await loadStatusDetail("ses_project", project);
+        expect(status.state === "unavailable" && status.reason).toEqual({
+            kind: "rpc_error",
+            message: "from the project server",
+        });
+        expect(await getCompartmentCount("ses_project", project)).toEqual({ ok: true, count: 72 });
+        // The startup directory still reaches the startup server.
+        const homeStatus = await loadStatusDetail("ses_project", home);
+        expect(homeStatus.state === "unavailable" && homeStatus.reason).toEqual({
+            kind: "not_tracked",
+            cause: "home_directory",
         });
     });
 
+    test("finds the session's server when the host spells its directory differently", async () => {
+        // The server files its discovery record under the directory it was
+        // started with (here through a symlink, as macOS /var is to
+        // /private/var); the TUI asks with the resolved spelling.
+        const dataHome = makeDataHome();
+        const root = realpathSync(createTestTempDirFromPath(join(tmpdir(), "mc-spelling-")));
+        tempDirs.push(root);
+        const real = join(root, "Pictures", "project");
+        mkdirSync(real, { recursive: true });
+        const link = join(root, "project-link");
+        symlinkSync(real, link);
+        await startServer(
+            dataHome,
+            `${link}/`,
+            () => snapshot("ses_spelled", 300) as unknown as Record<string, unknown>,
+        );
+        initRpcClient("/home-startup");
+        expect((await loadSidebarSnapshot("ses_spelled", real)).inputTokens).toBe(300);
+    });
+
+    test("asks every local server for the session's owner when no directory matches", async () => {
+        const dataHome = makeDataHome();
+        const home = await startServer(dataHome, "/home-startup", () => ({
+            sessionId: "ses_owned",
+            disabled: true,
+        }));
+        home.handle("session-owner", async () => ({ owner: false }));
+        const project = await startServer(
+            dataHome,
+            "/filed/under/this/spelling",
+            () => snapshot("ses_owned", 500) as unknown as Record<string, unknown>,
+        );
+        project.handle("session-owner", async (params) => ({
+            owner: params.sessionId === "ses_owned",
+        }));
+        initRpcClient("/home-startup");
+
+        // A spelling no canonical form maps to the filed one.
+        const snapshotSeen = await loadSidebarSnapshot("ses_owned", "/asked/with/another/spelling");
+        expect(snapshotSeen.inputTokens).toBe(500);
+        expect(snapshotSeen.compartmentCount).toBe(2);
+    });
+
     test("distinguishes a real zero compartment count from an RPC failure", async () => {
         const dataHome = makeDataHome();
         const directory = "/repo-count";