@cortexkit/opencode-magic-context 0.41.0 → 0.41.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.41.0",
+  "version": "0.41.1",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",
@@ -35,7 +35,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p ../retina-local-fs/tsconfig.build.json && bun run build:tui && rm -f dist/index.js dist/*-*.js && bun build src/index.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --external @huggingface/transformers --external onnxruntime-web --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
+    "build": "tsc -p ../retina-local-fs/tsconfig.build.json && bun run build:tui && rm -f dist/index.js dist/transformers-web.js dist/*-*.js && bun build src/features/magic-context/memory/transformers-web-entry.ts --outfile dist/transformers-web.js --target browser --format esm --external onnxruntime-web && bun build src/index.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --external onnxruntime-node --external onnxruntime-web --external sharp --external bun:sqlite --external node:sqlite && tsc --emitDeclarationOnly",
     "build:tui": "bun scripts/build-tui.ts",
     "check:tui-compiled": "bun run build:tui && git diff --exit-code -- src/tui-compiled && test -z \"$(git status --porcelain -- src/tui-compiled)\"",
     "typecheck": "tsc -p ../retina-local-fs/tsconfig.build.json && tsc --noEmit && tsc -p tsconfig.scripts.json",
@@ -51,7 +51,6 @@
   },
   "dependencies": {
     "@cortexkit/subc-client": "0.4.1",
-    "@huggingface/transformers": "^4.1.0",
     "@jitl/quickjs-singlefile-cjs-release-asyncify": "0.32.0",
     "@opencode-ai/plugin": "^1.17.11",
     "@opencode-ai/sdk": "^1.17.11",
@@ -65,8 +64,13 @@
     "solid-js": "1.9.12",
     "zod": "^4.1.8"
   },
+  "optionalDependencies": {
+    "onnxruntime-node": "1.24.3",
+    "sharp": "^0.34.5"
+  },
   "devDependencies": {
     "@ai-sdk/anthropic": "3.0.82",
+    "@huggingface/transformers": "^4.1.0",
     "@ai-sdk/openai-compatible": "2.0.41",
     "@biomejs/biome": "^2.5.1",
     "@types/better-sqlite3": "^7.6.13",

package/src/config/index.test.ts

@@ -2,7 +2,9 @@ import { describe, expect, it } from "bun:test";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+
 import { resolveHistorianModel } from "../shared/model-resolution";
+import { createTestTempDir } from "../shared/test-temp-dir";
 import { loadPluginConfig, loadPluginConfigDetailed } from "./index";
 import { resolveConfigProfile } from "./profiles";
 import { DEFAULT_LOCAL_EMBEDDING_MODEL } from "./schema/magic-context";
@@ -121,6 +123,7 @@ describe("loadPluginConfig — preload user-config isolation", () => {
             expect(loadPluginConfig(projectDir).embedding).toEqual({
                 provider: "local",
                 model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+                local_runtime: "auto",
             });
         } finally {
             rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
@@ -693,7 +696,8 @@ describe("loadPluginConfig — legacy agent enabled migration", () => {
 
 describe("loadPluginConfig — variable expansion scope", () => {
     it("keeps {env:} and {file:} expansion enabled for user config", () => {
-        const secretFile = join(mkdtempSync(join(tmpdir(), "mc-config-secret-")), "secret.txt");
+        const { dir: secretDir, cleanup } = createTestTempDir("mc-config-secret-");
+        const secretFile = join(secretDir, "secret.txt");
         writeFileSync(secretFile, "file-secret", "utf-8");
 
         try {
@@ -715,12 +719,13 @@ describe("loadPluginConfig — variable expansion scope", () => {
             }
             expect(result.configWarnings).toBeUndefined();
         } finally {
-            rmSync(secretFile, { force: true });
+            cleanup();
         }
     });
 
     it("leaves {env:} and {file:} tokens literal in project config and warns", () => {
-        const secretFile = join(mkdtempSync(join(tmpdir(), "mc-config-secret-")), "secret.txt");
+        const { dir: secretDir, cleanup } = createTestTempDir("mc-config-secret-");
+        const secretFile = join(secretDir, "secret.txt");
         writeFileSync(secretFile, "project-file-secret", "utf-8");
 
         try {
@@ -743,7 +748,7 @@ describe("loadPluginConfig — variable expansion scope", () => {
             expect(warnings).toContain("security reasons");
             expect(warnings).toContain("embedding.endpoint/provider");
         } finally {
-            rmSync(secretFile, { force: true });
+            cleanup();
         }
     });
 

package/src/config/schema/magic-context.test.ts

@@ -30,6 +30,7 @@ describe("MagicContextConfigSchema", () => {
                 embedding: {
                     provider: "local",
                     model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+                    local_runtime: "auto",
                 },
                 memory: {
                     enabled: true,
@@ -654,17 +655,35 @@ describe("MagicContextConfigSchema", () => {
             ).toThrow();
         });
 
+        it("defaults local embedding runtime to auto and accepts explicit overrides", () => {
+            expect(
+                MagicContextConfigSchema.parse({ embedding: { provider: "local" } }).embedding,
+            ).toMatchObject({ local_runtime: "auto" });
+            expect(
+                MagicContextConfigSchema.parse({
+                    embedding: { provider: "local", local_runtime: "wasm" },
+                }).embedding,
+            ).toMatchObject({ local_runtime: "wasm" });
+            expect(
+                MagicContextConfigSchema.safeParse({
+                    embedding: { provider: "local", local_runtime: "unsafe" },
+                }).success,
+            ).toBe(false);
+        });
+
         it("accepts a configured local embedding dtype", () => {
             const result = MagicContextConfigSchema.parse({
                 embedding: {
                     provider: "local",
                     model: "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+                    local_runtime: "auto",
                     local_dtype: "q8",
                 },
             });
             expect(result.embedding).toEqual({
                 provider: "local",
                 model: "Xenova/paraphrase-multilingual-MiniLM-L12-v2",
+                local_runtime: "auto",
                 local_dtype: "q8",
             });
         });
@@ -676,6 +695,7 @@ describe("MagicContextConfigSchema", () => {
             expect(result.embedding).toEqual({
                 provider: "local",
                 model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+                local_runtime: "auto",
             });
             expect("local_dtype" in result.embedding).toBe(false);
         });

package/src/config/schema/magic-context.ts

@@ -619,6 +619,12 @@ const BaseEmbeddingConfigSchema = z
             .describe(
                 "Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted.",
             ),
+        local_runtime: z
+            .enum(["auto", "native", "wasm"])
+            .default("auto")
+            .describe(
+                "Local provider only: ONNX runtime selection. 'auto' uses native under Node and uses WASM under Bun versions before 1.4.0, where Bun's NAPI teardown race can panic on quit; native is restored automatically on Bun 1.4.0+. Set 'native' only to prefer speed while accepting that pre-1.4.0 Bun crash risk, or 'wasm' to avoid loading the native addon.",
+            ),
         local_dtype: z
             .enum([
                 "auto",
@@ -685,6 +691,7 @@ export const EmbeddingConfigSchema = BaseEmbeddingConfigSchema.transform((data)
         return {
             provider: "local" as const,
             model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+            local_runtime: data.local_runtime,
             ...(data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {}),
             // local_dtype is spread CONDITIONALLY: omitting it when unset keeps
             // the identity byte-identical for the common no-dtype config, so
@@ -1161,6 +1168,7 @@ export const MagicContextConfigSchema = z
         embedding: EmbeddingConfigSchema.default({
             provider: "local",
             model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+            local_runtime: "auto",
         }).describe("Embedding provider configuration"),
         subc: z
             .object({

package/src/shared/conflict-detector.test.ts

@@ -1,10 +1,11 @@
 /// <reference types="bun-types" />
 
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+
 import { detectConflicts, resolveCompactionForBoot } from "./conflict-detector";
+import { cleanupTestTempDir, createTestTempDir } from "./test-temp-dir";
 
 /**
  * Regression tests for plugin-conflict detection. The previous substring-
@@ -13,13 +14,14 @@ import { detectConflicts, resolveCompactionForBoot } from "./conflict-detector";
  * a false-positive conflict warning. See issue #43.
  */
 describe("detectConflicts", () => {
+    let root: string;
     let projectDir: string;
     let userConfigDir: string;
     let homeDir: string;
     let originalEnv: Record<string, string | undefined>;
 
     beforeEach(() => {
-        const root = mkdtempSync(join(tmpdir(), "mc-conflict-"));
+        root = createTestTempDir("mc-conflict-").dir;
         projectDir = join(root, "project");
         mkdirSync(projectDir, { recursive: true });
         userConfigDir = join(root, "user-config", "opencode");
@@ -50,22 +52,7 @@ describe("detectConflicts", () => {
             if (v === undefined) delete process.env[k];
             else process.env[k] = v;
         }
-        // Test directories live under tmpdir(); cleanup is best-effort.
-        try {
-            rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        } catch {
-            /* Ignore EBUSY on Windows */
-        }
-        try {
-            rmSync(userConfigDir, {
-                recursive: true,
-                force: true,
-                maxRetries: 10,
-                retryDelay: 100,
-            });
-        } catch {
-            /* Ignore EBUSY on Windows */
-        }
+        cleanupTestTempDir(root);
     });
 
     function writeProjectConfig(plugins: Array<string | [string, unknown]>): void {

package/src/shared/conflict-fixer.test.ts

@@ -1,12 +1,13 @@
 /// <reference types="bun-types" />
 
 import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse as parseJsonc } from "comment-json";
+
 import { detectConflicts } from "./conflict-detector";
 import { fixConflicts } from "./conflict-fixer";
+import { cleanupTestTempDir, createTestTempDir } from "./test-temp-dir";
 
 const noOmoConflicts = {
     omoPreemptiveCompaction: false,
@@ -22,7 +23,7 @@ describe("fixConflicts", () => {
     let originalEnv: Record<string, string | undefined>;
 
     beforeEach(() => {
-        root = mkdtempSync(join(tmpdir(), "mc-conflict-fixer-"));
+        root = createTestTempDir("mc-conflict-fixer-").dir;
         projectDir = join(root, "project");
         userConfigDir = join(root, "user-config", "opencode");
         homeDir = join(root, "home");
@@ -44,11 +45,7 @@ describe("fixConflicts", () => {
             if (value === undefined) delete process.env[key];
             else process.env[key] = value;
         }
-        try {
-            rmSync(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
-        } catch {
-            /* Ignore EBUSY on Windows */
-        }
+        cleanupTestTempDir(root);
     });
 
     it("preserves JSONC comments and tuple plugin entries while removing canonical DCP", () => {

package/src/shared/logger.test.ts

@@ -18,49 +18,121 @@ type LoggerScenarioResult = {
     };
 };
 
+type RotationScenarioResult = {
+    firstCurrent: string;
+    firstPredecessorFirstByte: number;
+    current: string;
+    predecessorFirstByte: number;
+    predecessorSize: number;
+    currentSize: number;
+    currentMode: number;
+    predecessorMode: number;
+    files: string[];
+};
+
+type HotPathScenarioResult = {
+    statCalls: number;
+};
+
 const loggerScenario = `
-import { existsSync, readFileSync } from "node:fs";
+import fs from "node:fs";
 import * as path from "node:path";
+import { mock } from "bun:test";
 
 const root = process.env.LOGGER_SCENARIO_ROOT;
 const loggerModuleUrl = process.env.LOGGER_MODULE_URL;
-if (!root || !loggerModuleUrl) throw new Error("logger scenario environment is incomplete");
+const scenario = process.env.LOGGER_SCENARIO;
+if (!root || !loggerModuleUrl || !scenario) {
+    throw new Error("logger scenario environment is incomplete");
+}
 
-const logger = await import(loggerModuleUrl);
 const logPath = path.join(root, "nested", "magic-context.log");
 process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
-logger.log("first");
-logger.log(
-    "tokens.input=45000 api_key=sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGH",
-    { authorization: "Bearer abcdefghijklmnop", totalInputTokens: 132000 },
-);
-logger.flushLogger();
-const healthyDiagnostics = logger.getLoggerDiagnostics();
-
-const logDirectory = path.dirname(logPath);
-if (process.env.LOGGER_SCENARIO === "recovery") {
-    const { rmSync } = await import("node:fs");
-    rmSync(logDirectory, { recursive: true, force: true });
-    logger.log("second");
-    logger.flushLogger();
+let statCalls = 0;
+if (scenario === "hot-path") {
+    mock.module("node:fs", () => ({
+        ...fs,
+        statSync: (...args) => {
+            statCalls++;
+            return fs.statSync(...args);
+        },
+    }));
 }
 
-// A directory used as the file target makes append fail deterministically on every platform.
-const failedPath = path.join(root, "unwritable-log-target");
-const { mkdirSync } = await import("node:fs");
-mkdirSync(failedPath, { recursive: true });
-process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
-logger.log("failed write");
-logger.flushLogger();
-const failedDiagnostics = logger.getLoggerDiagnostics();
-
-const content = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
-console.log(JSON.stringify({
-    exists: existsSync(logPath),
-    content,
-    healthyDiagnostics,
-    failedDiagnostics,
-}));
+const logger = await import(loggerModuleUrl);
+
+if (scenario === "rotation") {
+    const maxLogBytes = 32 * 1024 * 1024;
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.writeFileSync(logPath, Buffer.alloc(maxLogBytes, "o"));
+    fs.chmodSync(logPath, 0o600);
+    fs.writeFileSync(logPath + ".1", "prior predecessor");
+
+    logger.log("after first rotation");
+    logger.flushLogger();
+    const firstCurrent = fs.readFileSync(logPath, "utf8");
+    const firstPredecessorFirstByte = fs.readFileSync(logPath + ".1")[0];
+
+    // Switch paths once so the logger rechecks the primary path after this
+    // external replacement, as a different plugin process would require.
+    fs.writeFileSync(logPath, Buffer.alloc(maxLogBytes, "n"));
+    process.env.MAGIC_CONTEXT_LOG_PATH = path.join(root, "alternate.log");
+    logger.log("alternate path");
+    logger.flushLogger();
+    process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
+    logger.log("after second rotation");
+    logger.flushLogger();
+
+    const predecessorPath = logPath + ".1";
+    console.log(JSON.stringify({
+        firstCurrent,
+        firstPredecessorFirstByte,
+        current: fs.readFileSync(logPath, "utf8"),
+        predecessorFirstByte: fs.readFileSync(predecessorPath)[0],
+        predecessorSize: fs.statSync(predecessorPath).size,
+        currentSize: fs.statSync(logPath).size,
+        currentMode: fs.statSync(logPath).mode & 0o777,
+        predecessorMode: fs.statSync(predecessorPath).mode & 0o777,
+        files: fs.readdirSync(path.dirname(logPath)).filter((name) => name.startsWith("magic-context.log")).sort(),
+    }));
+} else if (scenario === "hot-path") {
+    for (let index = 0; index < 20; index++) {
+        logger.log("hot-path-" + index);
+        logger.flushLogger();
+    }
+    console.log(JSON.stringify({ statCalls }));
+} else {
+    logger.log("first");
+    logger.log(
+        "tokens.input=45000 api_key=sk-proj-abcdefghijklmnopqrstuvwxyzABCDEFGH",
+        { authorization: "Bearer abcdefghijklmnop", totalInputTokens: 132000 },
+    );
+    logger.flushLogger();
+    const healthyDiagnostics = logger.getLoggerDiagnostics();
+
+    const logDirectory = path.dirname(logPath);
+    if (scenario === "recovery") {
+        fs.rmSync(logDirectory, { recursive: true, force: true });
+        logger.log("second");
+        logger.flushLogger();
+    }
+
+    // A directory used as the file target makes append fail deterministically on every platform.
+    const failedPath = path.join(root, "unwritable-log-target");
+    fs.mkdirSync(failedPath, { recursive: true });
+    process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
+    logger.log("failed write");
+    logger.flushLogger();
+    const failedDiagnostics = logger.getLoggerDiagnostics();
+
+    const content = fs.existsSync(logPath) ? fs.readFileSync(logPath, "utf8") : "";
+    console.log(JSON.stringify({
+        exists: fs.existsSync(logPath),
+        content,
+        healthyDiagnostics,
+        failedDiagnostics,
+    }));
+}
 `;
 
 const scenarioRoots: string[] = [];
@@ -71,9 +143,9 @@ afterEach(() => {
     }
 });
 
-async function runLoggerScenario(
-    scenario: "recovery" | "diagnostics",
-): Promise<LoggerScenarioResult> {
+async function runLoggerScenario<T>(
+    scenario: "recovery" | "diagnostics" | "rotation" | "hot-path",
+): Promise<T> {
     const root = mkdtempSync(path.join(os.tmpdir(), "magic-context-logger-test-"));
     scenarioRoots.push(root);
     const child = Bun.spawn({
@@ -95,19 +167,19 @@ async function runLoggerScenario(
         new Response(child.stderr).text(),
     ]);
     expect(exitCode, stderr).toBe(0);
-    return JSON.parse(stdout.trim()) as LoggerScenarioResult;
+    return JSON.parse(stdout.trim()) as T;
 }
 
 describe("logger", () => {
     test("recreates a log directory removed while the process is running", async () => {
-        const result = await runLoggerScenario("recovery");
+        const result = await runLoggerScenario<LoggerScenarioResult>("recovery");
 
         expect(result.exists).toBe(true);
         expect(result.content).toContain("second");
     });
 
     test("redacts secrets while preserving numeric diagnostics", async () => {
-        const result = await runLoggerScenario("diagnostics");
+        const result = await runLoggerScenario<LoggerScenarioResult>("diagnostics");
 
         expect(result.content).toContain("tokens.input=45000");
         expect(result.content).toContain('"totalInputTokens":132000');
@@ -117,8 +189,31 @@ describe("logger", () => {
         expect(result.content).not.toContain("abcdefghijklmnop");
     });
 
+    test("rotates at the 32 MiB bound with one private predecessor", async () => {
+        const result = await runLoggerScenario<RotationScenarioResult>("rotation");
+        const maxLogBytes = 32 * 1024 * 1024;
+
+        expect(result.firstCurrent).toContain("after first rotation");
+        expect(result.firstPredecessorFirstByte).toBe("o".charCodeAt(0));
+        expect(result.current).toContain("after second rotation");
+        expect(result.predecessorFirstByte).toBe("n".charCodeAt(0));
+        expect(result.predecessorSize).toBeLessThanOrEqual(maxLogBytes);
+        expect(result.currentSize).toBeLessThanOrEqual(maxLogBytes);
+        expect(result.files).toEqual(["magic-context.log", "magic-context.log.1"]);
+        if (process.platform !== "win32") {
+            expect(result.currentMode).toBe(0o600);
+            expect(result.predecessorMode).toBe(0o600);
+        }
+    });
+
+    test("uses cached size between periodic rotation checks", async () => {
+        const result = await runLoggerScenario<HotPathScenarioResult>("hot-path");
+
+        expect(result.statCalls).toBeLessThanOrEqual(1);
+    });
+
     test("reports swallowed writes while healthy writes leave the counter at zero", async () => {
-        const result = await runLoggerScenario("diagnostics");
+        const result = await runLoggerScenario<LoggerScenarioResult>("diagnostics");
 
         expect(result.healthyDiagnostics).toEqual({
             swallowedWriteCount: 0,

package/src/shared/logger.ts

@@ -9,6 +9,12 @@ let buffer: string[] = [];
 let flushTimer: ReturnType<typeof setTimeout> | null = null;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
+const MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
+const SIZE_CHECK_INTERVAL_FLUSHES = 64;
+
+let activeLogFile: string | null = null;
+let activeLogSize: number | null = null;
+let flushesSinceSizeCheck = 0;
 
 export interface LoggerDiagnostics {
     swallowedWriteCount: number;
@@ -36,19 +42,126 @@ function ensureDir(filePath: string): void {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
 
+function isMissingFile(error: unknown): boolean {
+    return (
+        typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        (error as { code?: unknown }).code === "ENOENT"
+    );
+}
+
+function getCurrentLogSize(logFile: string): number {
+    if (
+        activeLogFile === logFile &&
+        activeLogSize !== null &&
+        flushesSinceSizeCheck < SIZE_CHECK_INTERVAL_FLUSHES
+    ) {
+        return activeLogSize;
+    }
+
+    try {
+        const stat = fs.statSync(logFile);
+        if (!stat.isFile()) {
+            throw new Error(`Magic Context log path is not a regular file: ${logFile}`);
+        }
+        // Logs can contain diagnostic context, so tighten files created by older
+        // versions before copying or appending any new content.
+        fs.chmodSync(logFile, 0o600);
+        activeLogFile = logFile;
+        activeLogSize = stat.size;
+        flushesSinceSizeCheck = 0;
+        return stat.size;
+    } catch (error) {
+        if (!isMissingFile(error)) throw error;
+        activeLogFile = logFile;
+        activeLogSize = 0;
+        flushesSinceSizeCheck = 0;
+        return 0;
+    }
+}
+
+function capLogData(data: string): string {
+    if (Buffer.byteLength(data) <= MAX_LOG_FILE_BYTES) return data;
+
+    // A single diagnostic payload must not defeat the on-disk bound. Cutting a
+    // Buffer can split UTF-8, so trim any replacement character expansion too.
+    let bounded = Buffer.from(data).subarray(0, MAX_LOG_FILE_BYTES).toString("utf8");
+    while (Buffer.byteLength(bounded) > MAX_LOG_FILE_BYTES) {
+        bounded = bounded.slice(0, -1);
+    }
+    return bounded;
+}
+
+function writeBoundedPredecessor(logFile: string, predecessorPath: string, size: number): void {
+    const predecessorFd = fs.openSync(predecessorPath, "w", 0o600);
+    try {
+        // `openSync(..., "w")` preserves an existing file's mode, so set it
+        // before any copied diagnostic text reaches the predecessor.
+        fs.fchmodSync(predecessorFd, 0o600);
+        const bytesToCopy = Math.min(size, MAX_LOG_FILE_BYTES);
+        const sourceFd = fs.openSync(logFile, "r");
+        try {
+            const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, bytesToCopy));
+            let remaining = bytesToCopy;
+            let position = Math.max(0, size - bytesToCopy);
+            while (remaining > 0) {
+                const bytesRead = fs.readSync(
+                    sourceFd,
+                    chunk,
+                    0,
+                    Math.min(chunk.length, remaining),
+                    position,
+                );
+                if (bytesRead === 0) break;
+                fs.writeSync(predecessorFd, chunk, 0, bytesRead);
+                remaining -= bytesRead;
+                position += bytesRead;
+            }
+        } finally {
+            fs.closeSync(sourceFd);
+        }
+    } finally {
+        fs.closeSync(predecessorFd);
+    }
+}
+
+function rotateLogFile(logFile: string, size: number): void {
+    const predecessorPath = `${logFile}.1`;
+    writeBoundedPredecessor(logFile, predecessorPath, size);
+    // Keep the current inode in place so diagnostic readers can observe a
+    // shorter log during rotation instead of seeing the path disappear.
+    fs.truncateSync(logFile, 0);
+    activeLogSize = 0;
+    flushesSinceSizeCheck = 0;
+}
+
 function flush(): void {
     if (flushTimer) {
         clearTimeout(flushTimer);
         flushTimer = null;
     }
     if (buffer.length === 0) return;
-    const data = buffer.join("");
+    const bufferedData = buffer.join("");
     buffer = [];
     try {
+        const data = capLogData(bufferedData);
         const logFile = getMagicContextLogPath();
         ensureDir(logFile);
-        fs.appendFileSync(logFile, data);
+        let currentSize = getCurrentLogSize(logFile);
+        const dataSize = Buffer.byteLength(data);
+        if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+            rotateLogFile(logFile, currentSize);
+            currentSize = 0;
+        }
+        fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 0o600 });
+        activeLogFile = logFile;
+        activeLogSize = currentSize + dataSize;
+        flushesSinceSizeCheck++;
     } catch (error) {
+        activeLogFile = null;
+        activeLogSize = null;
+        flushesSinceSizeCheck = 0;
         recordSwallowedWrite(error);
     }
 }

package/src/shared/model-resolution.test.ts

@@ -9,9 +9,8 @@ import {
 } from "./model-resolution";
 
 describe("model-resolution", () => {
-    test("pins the historian calibration defaults while preserving explicit overrides", () => {
+    test("keeps historian temperature opt-in while preserving explicit overrides", () => {
         expect(resolveHistorianAgentOverrides(undefined)).toEqual({
-            temperature: 0.1,
             maxTokens: 32_000,
         });
         expect(
@@ -56,7 +55,7 @@ describe("model-resolution", () => {
         ]);
     });
 
-    test("applies the flash-calibrated historian generation triple while preserving overrides", () => {
+    test("keeps the flash calibration available only as an explicit override", () => {
         expect(
             resolveHistorianAgentOverrides({
                 opencode: { model: { model: "google/flash", variant: "fast" } },
@@ -64,15 +63,14 @@ describe("model-resolution", () => {
                 two_pass: true,
             }),
         ).toEqual({
-            temperature: 0.1,
             maxTokens: 32_000,
             two_pass: true,
             model: "google/flash",
             variant: "fast",
         });
         expect(
-            resolveHistorianAgentOverrides({ temperature: 0.2, maxTokens: 12_000 }),
-        ).toMatchObject({ temperature: 0.2, maxTokens: 12_000 });
+            resolveHistorianAgentOverrides({ temperature: 0.1, maxTokens: 12_000 }),
+        ).toMatchObject({ temperature: 0.1, maxTokens: 12_000 });
     });
 
     test("does not inherit a block qualifier into unqualified fallbacks", () => {