@cortexkit/opencode-magic-context 0.41.3 → 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

@@ -10,6 +10,8 @@ import {
 import packageJson from "../../package.json"
 import { closeRpc, dismissUpgradeReminder, getAnnouncement, getCompartmentCount, getRpcGeneration, initRpcClient, loadEmbedDetail, loadStatusDetail, loadToastDurationMs, markAnnounced, requestRecomp, requestUpgrade, type EmbedDetail, type StatusDetail } from "./data/context-db"
 import { startNotificationSocket, stopNotificationSocket, type SocketNotification } from "./data/notification-socket"
+import { formatCacheTtlDisplay } from "../shared/cache-ttl-display"
+import { formatConfigParseStatusLine } from "../shared/config-diagnostics"
 import { formatThresholdPercent } from "../shared/format-threshold"
 import { formatTailHygiene } from "../shared/tail-hygiene-status"
 import { RUST_MODE_HOST_PATHS_LINE } from "../shared/rust-mode-status"
@@ -204,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)
@@ -228,6 +230,10 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                 <text fg={t().textMuted}>v{packageJson.version}</text>
             </box>
 
+            {s().configParseFailures.map((failure) => (
+                <text fg={t().error}>{formatConfigParseStatusLine(failure)}</text>
+            ))}
+
             <box flexDirection="row" justifyContent="space-between" width="100%">
                 {compactionOff() ? (
                     <text fg={t().accent}>
@@ -273,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()}
@@ -378,7 +384,15 @@ const StatusDialog = (props: { api: TuiPluginApi; s: StatusDetail }) => {
                             <box marginTop={1}>
                                 <text fg={t().text}><b>Cache TTL</b></text>
                             </box>
-                            <R t={t()} l="Configured" v={s().cacheTtl} />
+                            <R
+                                t={t()}
+                                l="Configured"
+                                v={formatCacheTtlDisplay({
+                                    value: s().cacheTtl,
+                                    source: s().cacheTtlSource,
+                                    modelKey: s().cacheTtlModelKey,
+                                }).replace(/^Cache TTL: /, "")}
+                            />
                             <R t={t()} l="Last response" v={s().lastResponseTime > 0 ? `${Math.round(elapsed() / 1000)}s ago` : "never"} />
                             <R t={t()} l="Remaining" v={s().cacheExpired ? "expired" : s().cacheNeverExpires ? "never (MC never assumes expiry — external cache-keep)" : `${Math.round(s().cacheRemainingMs / 1000)}s`} fg={s().cacheExpired ? t().warning : t().textMuted} />
                             <R t={t()} l="Auto-execute" v={s().cacheExpired ? "yes (expired)" : s().cacheNeverExpires ? `at ≥${formatThresholdPercent(s().executeThreshold)}%` : `at TTL or ≥${formatThresholdPercent(s().executeThreshold)}%`} fg={t().textMuted} />
@@ -501,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}
                         />
                     )}