@cortexkit/opencode-magic-context 0.41.4 → 0.42.0

package/src/shared/window-geometry.ts

@@ -10,7 +10,12 @@ export const PROMPT_WALL_MARGIN = 4_096;
 export const PI_OUTPUT_FLOOR = 4_096;
 export const OPENCODE_OUTPUT_CAP = 32_000;
 
-const MIN_PLAUSIBLE_CONTEXT_LIMIT = 1_024;
+/**
+ * Smallest context window any served model can plausibly have. Reported or
+ * inferred limits below this are placeholders (0, 1) or corrupt state, never a
+ * real window, so every denominator check shares this one floor.
+ */
+export const MIN_PLAUSIBLE_CONTEXT_LIMIT = 1_024;
 const OUTPUT_RESERVE_CAP_RATIO = 0.25;
 
 export type WindowGeometry = "shared_upfront" | "shared_truncating" | "separate";
@@ -70,11 +75,15 @@ export interface ResolvedWindowOverlayFacts {
     facts: Record<string, WindowOverlayFact>;
 }
 
+export type WindowLimitSource = "catalog" | "overlay" | "provider" | "detected";
+
 export interface WindowDerivation {
     window: number;
     reserve: number;
     reserveSource: WindowReserveSource;
     geometry: WindowGeometry;
+    windowSource: WindowLimitSource;
+    absoluteWall: number;
 }
 
 export interface WindowGeometryResult {
@@ -446,20 +455,22 @@ export function deriveWindowGeometry(
     const catalogContext = isFinitePositive(catalogLimit?.context)
         ? catalogLimit.context
         : undefined;
+    const providerContext = isFinitePositive(providerLimit?.context)
+        ? providerLimit.context
+        : undefined;
     const advertised = numericOverlayFact(options.overlay, "window.advertised");
     const enforced = numericOverlayFact(options.overlay, "window.enforced");
-    let softContext = mergePositive(
-        enforced ?? advertised ?? catalogContext,
-        providerLimit?.context,
-    );
-    let hardContext = mergePositive(enforced ?? softContext, providerLimit?.context);
-    if (isFinitePositive(options.contextCap)) {
+    let softContext = mergePositive(enforced ?? advertised ?? catalogContext, providerContext);
+    let hardContext = mergePositive(enforced ?? softContext, providerContext);
+    const contextCap = isFinitePositive(options.contextCap) ? options.contextCap : undefined;
+    const hasContextCap = contextCap !== undefined;
+    if (contextCap !== undefined) {
         softContext = isFinitePositive(softContext)
-            ? Math.min(softContext, options.contextCap)
-            : options.contextCap;
+            ? Math.min(softContext, contextCap)
+            : contextCap;
         hardContext = isFinitePositive(hardContext)
-            ? Math.min(hardContext, options.contextCap)
-            : options.contextCap;
+            ? Math.min(hardContext, contextCap)
+            : contextCap;
     }
     const input = mergePositive(
         isFinitePositive(catalogLimit?.input) ? catalogLimit.input : undefined,
@@ -573,6 +584,13 @@ export function deriveWindowGeometry(
 
     const hardWindow = hardContext ?? softContext ?? input;
     if (!isFinitePositive(hardWindow)) return undefined;
+    const windowSource: WindowLimitSource = hasContextCap
+        ? "detected"
+        : providerContext !== undefined
+          ? "provider"
+          : enforced !== undefined || advertised !== undefined
+            ? "overlay"
+            : "catalog";
     let usableHard: number;
     if (geometry === "separate") {
         usableHard = hardWindow;
@@ -606,6 +624,66 @@ export function deriveWindowGeometry(
             reserve: Math.floor(Math.max(0, resolvedWindow - usableSoft)),
             reserveSource,
             geometry,
+            windowSource,
+            absoluteWall: Math.floor(hardWindow),
+        },
+    };
+}
+
+export interface ProvenInputFloorResult {
+    geometry: WindowGeometryResult;
+    refused?: { reading: number; absoluteWall: number };
+}
+
+export function hasTrustedAbsoluteWall(geometry: WindowGeometryResult): boolean {
+    return geometry.derivation.windowSource !== "catalog";
+}
+
+/**
+ * Successful requests can disprove static catalog metadata, but cannot
+ * disprove a provider, overlay, or observed-overflow wall. A reading beyond
+ * that wall is malformed usage accounting and must not enlarge the geometry.
+ */
+export function applyProvenInputFloor(
+    geometry: WindowGeometryResult,
+    provenInputTokens: number | undefined,
+): ProvenInputFloorResult {
+    if (
+        !isFinitePositive(provenInputTokens) ||
+        provenInputTokens < MIN_PLAUSIBLE_CONTEXT_LIMIT ||
+        provenInputTokens <= geometry.usableSoft
+    ) {
+        return { geometry };
+    }
+    if (hasTrustedAbsoluteWall(geometry) && provenInputTokens > geometry.derivation.absoluteWall) {
+        return {
+            geometry,
+            refused: {
+                reading: provenInputTokens,
+                absoluteWall: geometry.derivation.absoluteWall,
+            },
+        };
+    }
+
+    const trustedAbsoluteWall = hasTrustedAbsoluteWall(geometry);
+    const window = trustedAbsoluteWall
+        ? geometry.derivation.window
+        : Math.max(geometry.derivation.window, provenInputTokens);
+    return {
+        geometry: {
+            ...geometry,
+            usableSoft: provenInputTokens,
+            usableHard: trustedAbsoluteWall
+                ? geometry.usableHard
+                : Math.max(geometry.usableHard, provenInputTokens),
+            derivation: {
+                ...geometry.derivation,
+                window,
+                reserve: Math.max(0, window - provenInputTokens),
+                absoluteWall: trustedAbsoluteWall
+                    ? geometry.derivation.absoluteWall
+                    : Math.max(geometry.derivation.absoluteWall, provenInputTokens),
+            },
         },
     };
 }

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

@@ -0,0 +1,241 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+const repoRoot = resolve(import.meta.dir, "../../../../");
+const beginImmediate = /\b(?:[A-Za-z_$][\w$]*\.)?exec\("BEGIN IMMEDIATE"\)/g;
+
+const fencedSources: Array<{ path: string; sites: string[] }> = [
+    {
+        path: "packages/plugin/src/features/magic-context/smart-notes/storage.ts",
+        sites: ["smart_note_commit"],
+    },
+    {
+        path: "packages/plugin/src/hooks/magic-context/inject-compartments.ts",
+        sites: ["opencode_materialize_cache", "opencode_soft_refresh_cache"],
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/message-index.ts",
+        sites: [
+            "message_index_incremental",
+            "message_index_reconcile",
+            "message_index_orphan_sweep",
+        ],
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/storage-meta-persisted.ts",
+        sites: [
+            "storage_meta_wrapup_expiry_cleanup",
+            "storage_meta_wrapup_acquire",
+            "storage_meta_wrapup_update",
+            "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"],
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/project-embedding-registry.ts",
+        sites: ["embedding_identity_record", "embedding_stale_gc"],
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/workspaces.ts",
+        sites: ["workspace_epoch_bump", "workspace_epoch_bump"],
+    },
+    {
+        // The chokepoint cannot import the logging chain (Node executes it
+        // directly), so it reports through the injected reporter instead.
+        path: "packages/plugin/src/shared/sqlite.ts",
+        sites: ["privileged_writer"],
+        reporterCall: "reportSlowPrivilegedWrite?.(",
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/git-commits/sweep-coordinator.ts",
+        sites: ["git_sweep_lease"],
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/session-project-backfill.ts",
+        sites: ["session_project_backfill"],
+    },
+    {
+        path: "packages/plugin/src/tools/ctx-memory/verification-recording.ts",
+        sites: ["ctx_memory_mutation"],
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/storage-clone.ts",
+        sites: ["storage_clone_copy"],
+    },
+    {
+        path: "packages/plugin/src/hooks/magic-context/compartment-runner-recomp.ts",
+        sites: ["historian-publish:recomp"],
+    },
+    {
+        path: "packages/plugin/src/hooks/magic-context/compartment-runner-incremental.ts",
+        sites: ["historian-publish"],
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/dreamer/lease.ts",
+        sites: ["lease_dynamic_site"],
+    },
+    {
+        path: "packages/pi-plugin/src/inject-compartments-pi.ts",
+        sites: ["pi_materialize_cache", "pi_soft_refresh_cache"],
+    },
+    {
+        path: "packages/pi-plugin/src/pi-historian-runner.ts",
+        sites: ["pi_historian_publish"],
+    },
+    {
+        path: "packages/pi-plugin/src/context-handler.ts",
+        sites: ["pi_compaction_queue"],
+    },
+];
+
+const nonBeginCoveredSites: Array<{ path: string; site: string }> = [
+    {
+        path: "packages/plugin/src/features/magic-context/message-index.ts",
+        site: "message_index_clear",
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/message-fts-rowid-map.ts",
+        site: "message_fts_rowid_backfill",
+    },
+    {
+        path: "packages/plugin/src/hooks/magic-context/note-nudger.ts",
+        site: "note_nudge_trigger",
+    },
+    {
+        path: "packages/plugin/src/features/magic-context/user-memory/storage-user-memory.ts",
+        site: "user_memory_candidate_insert",
+    },
+];
+
+let scenarioRoot: string | null = null;
+let scenarioLogPath: string | null = null;
+
+const newlyCoveredSites = [
+    "opencode_materialize_cache",
+    "opencode_soft_refresh_cache",
+    "message_index_incremental",
+    "message_index_reconcile",
+    "message_index_orphan_sweep",
+    "message_index_clear",
+    "message_fts_rowid_backfill",
+    "storage_meta_wrapup_expiry_cleanup",
+    "storage_meta_wrapup_acquire",
+    "storage_meta_wrapup_update",
+    "storage_meta_wrapup_release",
+    "authority_marker_capture",
+    "authority_capture_check",
+    "compartment_state_replace",
+    "recomp_staging_promote",
+    "embedding_identity_record",
+    "embedding_stale_gc",
+    "workspace_epoch_bump",
+    "privileged_writer",
+    "git_sweep_lease",
+    "session_project_backfill",
+    "ctx_memory_mutation",
+    "storage_clone_copy",
+    "smart_note_commit",
+    "pi_materialize_cache",
+    "pi_soft_refresh_cache",
+    "pi_historian_publish",
+    "pi_compaction_queue",
+    "note_nudge_trigger",
+    "user_memory_candidate_insert",
+] as const;
+
+function sourceFor(relativePath: string): string {
+    return readFileSync(resolve(repoRoot, relativePath), "utf8");
+}
+
+function assertCoveredBeginImmediate(
+    source: string,
+    sites: string[],
+    reporterCall = "logSlowWriteTransaction(",
+): void {
+    const matches = [...source.matchAll(beginImmediate)];
+    expect(matches).toHaveLength(sites.length);
+    for (let index = 0; index < matches.length; index += 1) {
+        const match = matches[index];
+        const nextBegin = matches[index + 1]?.index ?? source.length;
+        const transactionRegion = source.slice(match.index, nextBegin);
+        expect(transactionRegion).toContain(reporterCall);
+        if (sites[index] === "lease_dynamic_site") {
+            expect(transactionRegion).toContain("logSlowWriteTransaction(site");
+        } else {
+            expect(transactionRegion).toContain(`"${sites[index]}"`);
+        }
+    }
+}
+
+describe("write transaction attribution fences", () => {
+    beforeAll(async () => {
+        scenarioRoot = mkdtempSync(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)});
+            const logger = await import(${JSON.stringify(new URL("./logger.ts", import.meta.url).href)});
+            for (const site of ${JSON.stringify(newlyCoveredSites)}) {
+                timing.logSlowWriteTransaction(site, 1_000, 1_000, 2_100);
+                timing.logSlowWriteTransaction(site, 2_000, 1_000, 2_100);
+            }
+            logger.flushLogger();
+        `;
+        const child = Bun.spawn({
+            cmd: ["bun", "--eval", scenario],
+            cwd: import.meta.dir,
+            env: {
+                ...process.env,
+                NODE_ENV: "production",
+                MAGIC_CONTEXT_LOG_PATH: scenarioLogPath,
+            },
+            stdout: "pipe",
+            stderr: "pipe",
+        });
+        const [exitCode, stderr] = await Promise.all([
+            child.exited,
+            new Response(child.stderr).text(),
+        ]);
+        expect(exitCode, stderr).toBe(0);
+    });
+
+    afterAll(() => {
+        if (scenarioRoot) rmSync(scenarioRoot, { recursive: true, force: true });
+        scenarioRoot = null;
+        scenarioLogPath = null;
+    });
+
+    test("lists every BEGIN IMMEDIATE writer and requires a covered site", () => {
+        for (const fencedSource of fencedSources) {
+            assertCoveredBeginImmediate(
+                sourceFor(fencedSource.path),
+                fencedSource.sites,
+                "reporterCall" in fencedSource ? fencedSource.reporterCall : undefined,
+            );
+        }
+        for (const coveredSite of nonBeginCoveredSites) {
+            expect(sourceFor(coveredSite.path)).toContain(
+                `logSlowWriteTransaction("${coveredSite.site}"`,
+            );
+        }
+    });
+
+    for (const site of newlyCoveredSites) {
+        test(`logs a slow and suppresses a sub-threshold transaction at site=${site}`, () => {
+            if (!scenarioLogPath) throw new Error("timing scenario did not start");
+            const lines = readFileSync(scenarioLogPath, "utf8")
+                .split("\n")
+                .filter((line) => line.includes(`site=${site}`));
+            expect(lines).toHaveLength(1);
+            expect(lines[0]).toContain("held=1100.0ms");
+        });
+    }
+});

package/src/shared/write-transaction-timing.ts

@@ -14,9 +14,10 @@ export function logSlowWriteTransaction(
     site: string,
     startedAt: number,
     thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS,
+    completedAtMs = performance.now(),
 ): void {
     try {
-        const durationMs = performance.now() - startedAt;
+        const durationMs = completedAtMs - startedAt;
         if (durationMs < thresholdMs) return;
         log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms`);
     } catch {

package/src/tui/index.tsx

@@ -206,7 +206,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
             segs.push({ label: "User Profile", tokens: d.profileTokens, color: COLORS.profile })
 
         if (d.conversationTokens > 0)
-            segs.push({ label: "Conversation*", tokens: d.conversationTokens, color: COLORS.conversation })
+            segs.push({ label: "Conversation", tokens: d.conversationTokens, color: COLORS.conversation })
         if (d.toolCallTokens > 0)
             segs.push({ label: "Tool Calls", tokens: d.toolCallTokens, color: COLORS.toolCalls })
         if (d.toolDefinitionTokens > 0)
@@ -279,7 +279,7 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                         </box>
                     )
                 })}
-                <text fg={t().textMuted}>* Conversation includes Reasoning; hygiene excludes it</text>
+                <text fg={t().textMuted}>Conversation includes reasoning; hygiene excludes it</text>
                 {s().tailHygiene !== undefined && (
                     <R
                         t={t()}
@@ -515,7 +515,7 @@ async function showRecompDialog(api: TuiPluginApi, targetSessionId = getSessionI
                     ? "This session has no compartments yet — recomp will build them from raw history."
                     : `You have ${count} compartments.`,
                 "",
-                "Recomp will regenerate all compartments and facts from raw history.",
+                "Recomp will rebuild the compressed history from raw history. Saved memories are not changed.",
                 "This may take a long time and consume significant tokens.",
                 "",
                 "Proceed?",

package/src/tui/slots/sidebar-content.tsx

@@ -5,7 +5,6 @@ import packageJson from "../../../package.json"
 import { badgeTextColor } from '../badge-contrast';
 import { loadSidebarSnapshot, type SidebarSnapshot } from "../data/context-db"
 import { formatThresholdPercent } from "../../shared/format-threshold"
-import { formatTailHygiene } from "../../shared/tail-hygiene-status"
 import { compactionOffSidebarRows, nativeCompactionContextLabel } from "../compaction-off"
 import {
     computeEffectiveOrder,
@@ -106,6 +105,16 @@ function compactTokens(value: number): string {
     return String(value)
 }
 
+/**
+ * Sidebar form of the tail-hygiene reading: the reclaimable share and the
+ * two masses it is computed from, in the same compact token unit as the
+ * breakdown rows so the value fits beside its label at sidebar width. The
+ * long, unit-spelled form stays in the status dialog.
+ */
+function hygieneValue(status: { severity: number; u: number; t: number }): string {
+    return `${(status.severity * 100).toFixed(1)}% · ${compactTokens(status.u)}/${compactTokens(status.t)}`
+}
+
 function relativeTime(ms: number): string {
     const diff = Date.now() - ms
     if (diff < 60_000) return "just now"
@@ -240,7 +249,7 @@ const TokenBreakdown = (props: {
             key: "conv",
             tokens: s.conversationTokens,
             color: COLORS.conversation,
-            label: "Conversation*",
+                label: "Conversation",
         })
 
         // Tool Calls = tool_use/tool_result/tool/tool-invocation parts in messages
@@ -321,7 +330,6 @@ const TokenBreakdown = (props: {
                             </box>
                         )
                     })}
-                    <text fg={props.theme.textMuted}>* includes Reasoning; hygiene excludes it</text>
                 </box>
             )}
         </box>
@@ -798,14 +806,11 @@ const SidebarContent = (props: {
                         </box>
                     )}
                     <TokenBreakdown theme={props.theme} snapshot={s()!} collapsed={collapsed()} />
-                    {!collapsed() && (
-                        <text fg={props.theme.textMuted}>Conversation includes reasoning estimates; hygiene excludes reasoning.</text>
-                    )}
                     {s()!.tailHygiene !== undefined && (
                         <StatRow
                             theme={props.theme}
                             label="Hygiene"
-                            value={formatTailHygiene(s()!.tailHygiene!)}
+                            value={hygieneValue(s()!.tailHygiene!)}
                             warning={!s()!.tailHygiene!.evaluable}
                         />
                     )}

package/src/tui-compiled/index.tsx

@@ -201,7 +201,7 @@ const StatusDialog = props => {
       color: COLORS.profile
     });
     if (d.conversationTokens > 0) segs.push({
-      label: "Conversation*",
+      label: "Conversation",
       tokens: d.conversationTokens,
       color: COLORS.conversation
     });
@@ -384,7 +384,7 @@ const StatusDialog = props => {
         return _el$35;
       })();
     }), _el$15);
-    _$insertNode(_el$15, _$createTextNode(`* Conversation includes Reasoning; hygiene excludes it`));
+    _$insertNode(_el$15, _$createTextNode(`Conversation includes reasoning; hygiene excludes it`));
     _$insert(_el$14, (() => {
       var _c$4 = _$memo(() => s().tailHygiene !== undefined);
       return () => _c$4() && _$createComponent(R, {
@@ -1070,7 +1070,7 @@ async function showRecompDialog(api, targetSessionId = getSessionId(api)) {
   api.ui.dialog.replace(() => _$createComponent(api.ui.DialogConfirm, {
     title: "\u26A0\uFE0F Recomp Confirmation",
     get message() {
-      return [count === 0 ? "This session has no compartments yet — recomp will build them from raw history." : `You have ${count} compartments.`, "", "Recomp will regenerate all compartments and facts from raw history.", "This may take a long time and consume significant tokens.", "", "Proceed?"].join("\n");
+      return [count === 0 ? "This session has no compartments yet — recomp will build them from raw history." : `You have ${count} compartments.`, "", "Recomp will rebuild the compressed history from raw history. Saved memories are not changed.", "This may take a long time and consume significant tokens.", "", "Proceed?"].join("\n");
     },
     onConfirm: async () => {
       const requested = await requestRecomp(sessionId);