@cortexkit/opencode-magic-context 0.41.4 → 0.42.1

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

@@ -80,6 +80,34 @@ describe("prompt-surface runtime", () => {
         expect(changedModel.primaryOverride).toBe(second);
     });
 
+    it("shares one frozen guidance epoch between the system hook and Rust adapter", () => {
+        const directory = tempDir();
+        const path = join(directory, "guidance.md");
+        const first = "## Magic Context\n\nShared first epoch";
+        const second = "## Magic Context\n\nShared second epoch";
+        writeFileSync(path, first);
+        const runtime = createPromptSurfaceRuntime({
+            userConfigDirectory: directory,
+            warn: () => undefined,
+        });
+        const systemEpochs = createPromptSurfaceGuidanceEpochCache(runtime);
+        const adapterEpochs = createPromptSurfaceGuidanceEpochCache(runtime);
+        const config = {
+            default: "full" as const,
+            guidance_override_path: "guidance.md",
+        };
+
+        const systemInitial = systemEpochs.resolve("session", config, "provider/model");
+        writeFileSync(path, second);
+        const adapterDeferred = adapterEpochs.resolve("session", config, "provider/model");
+        expect(adapterDeferred).toBe(systemInitial);
+        expect(adapterDeferred.primaryOverride).toBe(first);
+
+        adapterEpochs.clear("session");
+        const systemNextEpoch = systemEpochs.resolve("session", config, "provider/model");
+        expect(systemNextEpoch.primaryOverride).toBe(second);
+    });
+
     it("uses registration default, applies known overrides, and reports invalid IDs", () => {
         const warnings: string[] = [];
         const runtime = createPromptSurfaceRuntime({

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

@@ -230,18 +230,33 @@ interface GuidanceEpoch {
     selection: PromptSurfaceGuidanceSelection;
 }
 
-/** Freeze preset selection and materialized override bytes for one model-key epoch. */
-export function createPromptSurfaceGuidanceEpochCache(runtime: PromptSurfaceRuntime): {
+export interface PromptSurfaceGuidanceEpochCache {
     resolve: (
         sessionId: string,
         config: PromptSurfaceConfig | undefined,
         modelKey: string | undefined,
     ) => PromptSurfaceGuidanceSelection;
     clear: (sessionId: string) => void;
-} {
-    const epochs = new Map<string, GuidanceEpoch>();
+}
 
-    return {
+const guidanceEpochCacheByRuntime = new WeakMap<
+    PromptSurfaceRuntime,
+    PromptSurfaceGuidanceEpochCache
+>();
+
+/**
+ * Freeze preset selection and materialized override bytes for one model-key epoch.
+ * Every hook using the same runtime also shares this cache, so a file edit cannot
+ * make the system hook and Rust adapter observe different bytes within one epoch.
+ */
+export function createPromptSurfaceGuidanceEpochCache(
+    runtime: PromptSurfaceRuntime,
+): PromptSurfaceGuidanceEpochCache {
+    const shared = guidanceEpochCacheByRuntime.get(runtime);
+    if (shared) return shared;
+
+    const epochs = new Map<string, GuidanceEpoch>();
+    const cache: PromptSurfaceGuidanceEpochCache = {
         resolve(sessionId, config, modelKey) {
             const canonicalModelKey = modelKey ? piModelRefToCanonical(modelKey) : undefined;
             const cached = epochs.get(sessionId);
@@ -257,4 +272,6 @@ export function createPromptSurfaceGuidanceEpochCache(runtime: PromptSurfaceRunt
             epochs.delete(sessionId);
         },
     };
+    guidanceEpochCacheByRuntime.set(runtime, cache);
+    return cache;
 }

package/src/shared/resolve-fallbacks.ts

@@ -2,7 +2,7 @@ import type { ModelInput, ResolvedModelEntry } from "./model-resolution";
 
 /**
  * Resolve the fallback model list to attempt for a hidden-agent (historian /
- * dreamer / sidekick) call when its configured primary fails.
+ * dreamer) call when its configured primary fails.
  *
  * Policy: ONLY the user's explicitly-configured `fallback_models` for this
  * agent. There is NO builtin provider-agnostic chain — a hardcoded chain

package/src/shared/rpc-types.ts

@@ -7,12 +7,15 @@ import type {
     DreamTaskBacklogMap,
     DreamTaskProgress,
 } from "../features/magic-context/dreamer/task-registry";
+import type { SynapseLaneDescriptor } from "../features/magic-context/memory/embedding-synapse";
 import type { ConfigParseFailure } from "./config-diagnostics";
 import type { LoggerDiagnostics } from "./logger";
 
 export interface TailHygieneStatus {
     /** Tokens in active, non-protected tail content that the agent can reclaim. */
     u: number;
+    /** Spent tool outputs contributing positive tokens to U in this baseline. */
+    reclaimableToolOutputCount?: number;
     /** Tokens in rendered-tail content eligible for hygiene accounting in the same scan. */
     t: number;
     /** Reclaimable-to-eligible token ratio, clamped to 0–1 and shared by both nudge mechanisms. */
@@ -54,6 +57,8 @@ export interface SidebarSnapshot {
     cacheTtl: string;
     /** Persistent runtime failure shown directly in the sidebar when non-null. */
     lastTransformError: string | null;
+    /** Durable history-compression failure count used to select the stable summary warning. */
+    historianFailureCount?: number;
     lastDreamerRunAt: number | null;
     projectIdentity: string | null;
     compartmentTokens: number;
@@ -169,6 +174,8 @@ export interface StatusDetail extends SidebarSnapshot {
             reserve: number;
             reserveSource: "output_catalog" | "output_config" | "wall_margin" | "none";
             geometry: "shared_upfront" | "shared_truncating" | "separate";
+            windowSource: "catalog" | "overlay" | "provider" | "detected";
+            absoluteWall: number;
         };
     };
     /**
@@ -221,6 +228,12 @@ export interface StatusDetail extends SidebarSnapshot {
      * (the plugin owns it), so this surface supplies the live DB value; the module
      * surface supplies the module-store value instead.
      */
+    /** Search-indexing coverage and current command state for the default status summary. */
+    embedding?: {
+        state: "off" | "running" | "paused" | "stopped" | "ready" | "waiting";
+        indexed: number;
+        total: number;
+    };
     storage_versions: {
         /**
          * Persisted schema version of context.db (MAX of schema_migrations).
@@ -239,12 +252,127 @@ export interface EmbedDetail {
     enabled: boolean;
     model: string;
     provider: string;
+    synapseDescriptor?: SynapseLaneDescriptor;
     session: { embedded: number; total: number };
     memories: { embedded: number; total: number };
     commits: { embedded: number; total: number; gitEnabled: boolean };
     statusText: string;
 }
 
+export interface DebugProcessMemoryUsage {
+    rss: number;
+    heapTotal: number;
+    heapUsed: number;
+    external: number;
+    arrayBuffers: number;
+}
+
+export interface DebugSessionHolderCount {
+    sessionId: string;
+    lkgBytes: number;
+    taggerAssignments: number;
+    taggerToolAccounting: number;
+    wireRawMessages: number;
+    wireMessages: number;
+    wireContentSnapshots: number;
+    wireEstimatedBytes: number;
+}
+
+export interface DebugMemoryHolders {
+    lkgSlots: {
+        count: number;
+        totalBytes: number;
+    };
+    taggerCache: {
+        sessionCount: number;
+        assignmentEntries: number;
+        toolAccountingEntries: number;
+        loadSignatureEntries: number;
+    };
+    wireCache: {
+        snapshots: number;
+        rawContentSnapshots: number;
+        estimatedBytes: number;
+    };
+    compartmentMirrors: {
+        entries: number;
+    };
+    messageIndexQueue: {
+        queueLength: number;
+        reconciliationScheduled: number;
+        incrementalTimers: number;
+        pendingIncremental: number;
+        activeSessionLocks: number;
+        completedIncrementalKeys: number;
+        activeBufferMessages: number;
+        activeBufferBytes: number;
+    };
+    sessions: DebugSessionHolderCount[];
+}
+
+export interface DebugSqliteConnectionMemoryStats {
+    sequence: number;
+    filename: string;
+    readonly: boolean;
+    pageSize: number | null;
+    pageCount: number | null;
+    freelistCount: number | null;
+    cacheSize: number | null;
+    cacheSizeUnit: "pages" | "kib" | null;
+    cacheUpperBoundBytes: number | null;
+    mmapSizeBytes: number | null;
+    walFileBytes: number | null;
+    shmFileBytes: number | null;
+    fts5TableCount: number | null;
+    journalMode: string | null;
+}
+
+export interface DebugNativeMemoryUsage {
+    sqlite: {
+        connectionCount: number;
+        cacheUpperBoundBytes: number;
+        mmapUpperBoundBytes: number;
+        walFileBytes: number;
+        shmFileBytes: number;
+        sqliteStatusApi: "unavailable";
+        connections: DebugSqliteConnectionMemoryStats[];
+    };
+    tokenizer: {
+        loaded: boolean;
+        loadAttempted: boolean;
+        tableBytes: number | null;
+        tablePath: string | null;
+    };
+    localEmbedding: {
+        loaded: boolean;
+        providerCount: number;
+        models: string[];
+        runtimes: Array<"native" | "wasm">;
+        modelCacheBytes: number | null;
+        rssDeltaAtLoad: number;
+        externalDeltaAtLoad: number;
+        arrayBuffersDeltaAtLoad: number;
+    };
+    quickJs: {
+        loadAttempted: boolean;
+        loaded: boolean;
+    };
+}
+
+export interface DebugMemoryUsageResponse {
+    pid: number;
+    bunVersion: string;
+    memoryUsage: DebugProcessMemoryUsage;
+    native: DebugNativeMemoryUsage;
+    holders: DebugMemoryHolders;
+}
+
+export interface DebugHeapSnapshotResponse extends DebugMemoryUsageResponse {
+    path: string;
+    format: "jsc" | "v8";
+    snapshotVersion?: number;
+}
+
 export interface RpcNotificationMessage {
     id: number;
     type: string;

package/src/shared/session-messages-bounded.test.ts

@@ -6,7 +6,7 @@
 // huge sessions (10k+ messages) which is exactly when Magic Context shines.
 //
 // Background: the plugin only ever needs the latest assistant message of a
-// helper subagent (historian / dreamer / sidekick / key-files / user-memory)
+// helper subagent (historian / dreamer / key-files / user-memory)
 // or a bounded tail of the active session (conflict-warning cleanup). Both
 // fit comfortably in `limit: 50` with massive headroom.
 //

package/src/shared/sqlite-import-fence.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// `sqlite.ts` is executed directly by Node in CI's `node:sqlite` smoke and by
+// Pi/Desktop hosts. Node's type-stripping loader does not resolve extensionless
+// relative imports, so a static import of any sibling module breaks that path
+// while every Bun-run test stays green (2026-09-12: master CI red for three
+// runs after a logging import landed here). Runtime dependencies must be
+// injected (see registerSlowWriteReporter); only type-only imports may be relative.
+describe("sqlite.ts import fence", () => {
+    test("has no runtime-relative imports", () => {
+        const source = readFileSync(join(import.meta.dir, "sqlite.ts"), "utf8");
+        const relativeRuntimeImports = source
+            .split("\n")
+            .filter((line) => /^import\s+(?!type\s)[^;]*from\s+["']\.\.?\//.test(line));
+        expect(relativeRuntimeImports).toEqual([]);
+    });
+});

package/src/shared/sqlite.test.ts

@@ -1,7 +1,33 @@
 import { describe, expect, it } from "bun:test";
-import { loadSqliteModule, SqliteRuntimeUnavailableError } from "./sqlite";
+import {
+    Database,
+    getSqliteMemoryStats,
+    loadSqliteModule,
+    SqliteRuntimeUnavailableError,
+} from "./sqlite";
 
 describe("SQLite runtime selector", () => {
+    it("reports live connection PRAGMAs and removes closed handles", () => {
+        const before = getSqliteMemoryStats().connectionCount;
+        const db = new Database(":memory:");
+        try {
+            db.exec("PRAGMA cache_size=-1024");
+            db.exec("CREATE VIRTUAL TABLE probe_fts USING fts5(content)");
+            const during = getSqliteMemoryStats();
+            expect(during.connectionCount).toBe(before + 1);
+            expect(during.connections.at(-1)).toMatchObject({
+                filename: ":memory:",
+                cacheSize: -1024,
+                cacheSizeUnit: "kib",
+                cacheUpperBoundBytes: 1024 * 1024,
+                fts5TableCount: 1,
+            });
+        } finally {
+            db.close();
+        }
+        expect(getSqliteMemoryStats().connectionCount).toBe(before);
+    });
+
     it("wraps a missing node:sqlite module with the detected runtime and cause", async () => {
         const cause = Object.assign(new Error("No such built-in module: node:sqlite"), {
             code: "ERR_UNKNOWN_BUILTIN_MODULE",

package/src/shared/sqlite.ts

@@ -39,12 +39,28 @@
  * `run()` → {changes,lastInsertRowid}) is identical and was verified directly.
  */
 
+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
 // we use, so calls typed against BetterSqlite3 work under bun:sqlite and
 // node:sqlite at runtime (both expose prepare/run/get/all/exec/close).
 import type BetterSqlite3 from "better-sqlite3";
 
+/**
+ * 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
+ * Node's type-stripping loader does not resolve extensionless imports, so any
+ * static import of the plugin's logging chain here breaks that path. The
+ * storage bootstrap registers the real reporter; until then slow privileged
+ * writes are simply not logged.
+ */
+type SlowWriteReporter = (site: string, transactionStartedAt: number) => void;
+let reportSlowPrivilegedWrite: SlowWriteReporter | undefined;
+
+export function registerSlowWriteReporter(reporter: SlowWriteReporter): void {
+    reportSlowPrivilegedWrite = reporter;
+}
+
 export type SqliteRuntime = "Bun" | "Node.js";
 
 type SqliteModule = {
@@ -158,6 +174,88 @@ const DatabaseImpl: typeof BetterSqlite3 = isBun
     ? (sqliteModule.Database as typeof BetterSqlite3)
     : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
 
+interface TrackedSqliteConnection {
+    sequence: number;
+    filename: string;
+    readonly: boolean;
+    reference: WeakRef<BetterSqlite3.Database>;
+}
+
+export interface SqliteConnectionMemoryStats {
+    sequence: number;
+    filename: string;
+    readonly: boolean;
+    pageSize: number | null;
+    pageCount: number | null;
+    freelistCount: number | null;
+    cacheSize: number | null;
+    cacheSizeUnit: "pages" | "kib" | null;
+    cacheUpperBoundBytes: number | null;
+    mmapSizeBytes: number | null;
+    walFileBytes: number | null;
+    shmFileBytes: number | null;
+    fts5TableCount: number | null;
+    journalMode: string | null;
+}
+
+export interface SqliteMemoryStats {
+    connectionCount: number;
+    cacheUpperBoundBytes: number;
+    mmapUpperBoundBytes: number;
+    walFileBytes: number;
+    shmFileBytes: number;
+    sqliteStatusApi: "unavailable";
+    connections: SqliteConnectionMemoryStats[];
+}
+
+const trackedSqliteConnections = new Map<number, TrackedSqliteConnection>();
+let nextSqliteConnectionSequence = 1;
+
+function trackSqliteConnection(
+    db: BetterSqlite3.Database,
+    filename: unknown,
+    options: unknown,
+): BetterSqlite3.Database {
+    const originalClose = db.close.bind(db) as (...args: unknown[]) => unknown;
+    const sequence = nextSqliteConnectionSequence++;
+    const metadata = {
+        sequence,
+        filename:
+            typeof filename === "string"
+                ? filename
+                : Buffer.isBuffer(filename)
+                  ? "<buffer>"
+                  : ":memory:",
+        readonly:
+            Boolean(options) &&
+            typeof options === "object" &&
+            ((options as { readonly?: unknown }).readonly === true ||
+                (options as { readOnly?: unknown }).readOnly === true),
+    };
+    Object.defineProperty(db, "close", {
+        configurable: true,
+        value: (...args: unknown[]) => {
+            try {
+                return originalClose(...args);
+            } finally {
+                trackedSqliteConnections.delete(sequence);
+            }
+        },
+    });
+    trackedSqliteConnections.set(sequence, {
+        ...metadata,
+        reference: new WeakRef(db),
+    });
+    return db;
+}
+
+const TrackedDatabase = new Proxy(DatabaseImpl, {
+    construct(target, args) {
+        const db = Reflect.construct(target, args, target) as BetterSqlite3.Database;
+        return trackSqliteConnection(db, args[0], args[1]);
+    },
+}) as typeof BetterSqlite3;
+
 /**
  * Wrap node:sqlite's `DatabaseSync` so it presents the better-sqlite3/bun
  * surface the rest of the codebase calls:
@@ -259,7 +357,108 @@ function buildNodeSqliteDatabaseClass(DatabaseSync: any): typeof BetterSqlite3 {
     return NodeSqliteDatabase as unknown as typeof BetterSqlite3;
 }
 
-export const Database: typeof BetterSqlite3 = DatabaseImpl;
+export const Database: typeof BetterSqlite3 = TrackedDatabase;
+
+function pragmaValue(db: BetterSqlite3.Database, name: string): unknown {
+    const row = db.prepare(`PRAGMA ${name}`).get() as Record<string, unknown> | undefined;
+    if (!row) return undefined;
+    return row[name] ?? Object.values(row)[0];
+}
+
+function pragmaNumber(db: BetterSqlite3.Database, name: string): number | null {
+    try {
+        const value = pragmaValue(db, name);
+        return typeof value === "number" && Number.isFinite(value) ? value : null;
+    } catch {
+        return null;
+    }
+}
+
+function pragmaString(db: BetterSqlite3.Database, name: string): string | null {
+    try {
+        const value = pragmaValue(db, name);
+        return typeof value === "string" ? value : null;
+    } catch {
+        return null;
+    }
+}
+
+function sqliteSidecarBytes(filename: string, suffix: "-wal" | "-shm"): number | null {
+    if (filename === ":memory:" || filename === "<buffer>") return 0;
+    try {
+        return statSync(`${filename}${suffix}`).size;
+    } catch (error) {
+        return (error as NodeJS.ErrnoException).code === "ENOENT" ? 0 : null;
+    }
+}
+
+function fts5TableCount(db: BetterSqlite3.Database): number | null {
+    try {
+        const row = db
+            .prepare(
+                "SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND sql LIKE '%USING fts5%'",
+            )
+            .get() as { count?: unknown } | undefined;
+        return typeof row?.count === "number" ? row.count : null;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Read the SQLite memory bounds that Bun/node:sqlite expose without native FFI.
+ * SQLite's sqlite3_status()/sqlite3_db_status() counters are not surfaced by
+ * either runtime, so cache and mmap values are configured upper bounds rather
+ * than resident-byte measurements.
+ */
+export function getSqliteMemoryStats(): SqliteMemoryStats {
+    const connections: SqliteConnectionMemoryStats[] = [];
+    for (const [sequence, tracked] of trackedSqliteConnections) {
+        const db = tracked.reference.deref();
+        if (!db) {
+            trackedSqliteConnections.delete(sequence);
+            continue;
+        }
+        const pageSize = pragmaNumber(db, "page_size");
+        const cacheSize = pragmaNumber(db, "cache_size");
+        const cacheSizeUnit = cacheSize === null ? null : cacheSize < 0 ? "kib" : "pages";
+        const cacheUpperBoundBytes =
+            cacheSize === null
+                ? null
+                : cacheSize < 0
+                  ? Math.abs(cacheSize) * 1024
+                  : pageSize === null
+                    ? null
+                    : cacheSize * pageSize;
+        connections.push({
+            sequence: tracked.sequence,
+            filename: tracked.filename,
+            readonly: tracked.readonly,
+            pageSize,
+            pageCount: pragmaNumber(db, "page_count"),
+            freelistCount: pragmaNumber(db, "freelist_count"),
+            cacheSize,
+            cacheSizeUnit,
+            cacheUpperBoundBytes,
+            mmapSizeBytes: pragmaNumber(db, "mmap_size"),
+            walFileBytes: sqliteSidecarBytes(tracked.filename, "-wal"),
+            shmFileBytes: sqliteSidecarBytes(tracked.filename, "-shm"),
+            fts5TableCount: fts5TableCount(db),
+            journalMode: pragmaString(db, "journal_mode"),
+        });
+    }
+    const sumKnown = (select: (connection: SqliteConnectionMemoryStats) => number | null): number =>
+        connections.reduce((sum, connection) => sum + (select(connection) ?? 0), 0);
+    return {
+        connectionCount: connections.length,
+        cacheUpperBoundBytes: sumKnown((connection) => connection.cacheUpperBoundBytes),
+        mmapUpperBoundBytes: sumKnown((connection) => connection.mmapSizeBytes),
+        walFileBytes: sumKnown((connection) => connection.walFileBytes),
+        shmFileBytes: sumKnown((connection) => connection.shmFileBytes),
+        sqliteStatusApi: "unavailable",
+        connections,
+    };
+}
 
 /** Instance type alias used by helpers and storage modules. */
 export type Database = BetterSqlite3.Database;
@@ -298,6 +497,7 @@ export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
     const previousDepth = privilegeDepth.get(db) ?? 0;
     const nested = isInTransaction(db);
     const savepoint = "mc_privilege_scope";
+    const transactionStartedAt = nested ? undefined : performance.now();
     if (nested) {
         db.exec(`SAVEPOINT ${savepoint}`);
     } else {
@@ -316,6 +516,9 @@ export function withPrivilegedWriter<T>(db: Database, operation: () => T): T {
             db.exec(`RELEASE ${savepoint}`);
         } else {
             db.exec("COMMIT");
+            if (transactionStartedAt !== undefined) {
+                reportSlowPrivilegedWrite?.("privileged_writer", transactionStartedAt);
+            }
         }
         if (previousDepth > 0) privilegeDepth.set(db, previousDepth);
         else privilegeDepth.delete(db);