@retaw106/mmc-oc 1.2.3 → 2.1.0

package/src/shared/provider-output-failure.ts

@@ -0,0 +1,176 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash } from "node:crypto";
+
+import { isRecord } from "./record-type-guard";
+
+const MAX_NEAR_ZERO_OUTPUT_TOKENS = 32;
+
+interface AssistantCompletionShape {
+    createdAt: number;
+    finish: string | null;
+    error: unknown;
+    outputTokens: number | null;
+    reasoningTokens: number | null;
+}
+
+/** A provider transport failure that arrived as an ordinary assistant completion. */
+export class ProviderOutputFailureError extends Error {
+    readonly transient = true;
+
+    constructor(
+        readonly fingerprint: string,
+        readonly outputTokens: number,
+        readonly reasoningTokens: number,
+        responseText: string,
+        readonly quotaResetAt?: number,
+    ) {
+        const preview = responseText.trim().replace(/\s+/g, " ").slice(0, 160);
+        super(
+            quotaResetAt !== undefined
+                ? `provider quota exhausted until ${new Date(quotaResetAt).toISOString()} (account-pool rate limit)`
+                : `provider outage completion (output_tokens=${outputTokens}, reasoning_tokens=${reasoningTokens}): ${JSON.stringify(preview)}`,
+        );
+        this.name = "ProviderOutputFailureError";
+    }
+}
+
+// Concurrent maintenance runs must not share provider health, and a new run
+// must re-probe its configured primary. Nested verify batches inherit the scope.
+const primaryQuotas = new AsyncLocalStorage<Map<string, ProviderOutputFailureError>>();
+
+export function withDreamerModelCooldown<T>(run: () => T): T {
+    return primaryQuotas.getStore() ? run() : primaryQuotas.run(new Map(), run);
+}
+
+export function rememberPrimaryQuota(
+    model: string,
+    error: unknown,
+): ProviderOutputFailureError | null {
+    const quotas = primaryQuotas.getStore();
+    if (
+        !quotas ||
+        model === "primary" ||
+        !(error instanceof ProviderOutputFailureError) ||
+        error.quotaResetAt === undefined ||
+        error.quotaResetAt <= Date.now()
+    )
+        return null;
+    const cached = new ProviderOutputFailureError(
+        error.fingerprint,
+        error.outputTokens,
+        error.reasoningTokens,
+        "",
+        error.quotaResetAt,
+    );
+    cached.message = error.message;
+    quotas.set(model, cached);
+    return error;
+}
+
+export function primaryQuotaFailure(model: string): ProviderOutputFailureError | null {
+    const quotas = primaryQuotas.getStore();
+    const error = quotas?.get(model);
+    if (!error) return null;
+    if (error.quotaResetAt === undefined || error.quotaResetAt <= Date.now()) {
+        quotas?.delete(model);
+        return null;
+    }
+    const failure = new ProviderOutputFailureError(
+        error.fingerprint,
+        error.outputTokens,
+        error.reasoningTokens,
+        "",
+        error.quotaResetAt,
+    );
+    failure.message = error.message;
+    return failure;
+}
+
+/** The auth adapter emits this entire notice as assistant text, not a host error.
+ * Match the envelope, never a quoted notice inside a real manifest or narration. */
+function quotaResetAt(responseText: string, now: number): number | undefined {
+    const notice =
+        /^All [1-9]\d* account\(s\) rate-limited for [\w.-]+\. Quota resets in ((?:\d+[hms] ?)+)\. Add more accounts with `opencode auth login` or wait and retry\.$/.exec(
+            responseText.trim(),
+        );
+    if (!notice) return undefined;
+    const units: Record<string, number> = { h: 3_600_000, m: 60_000, s: 1_000 };
+    const duration = [...notice[1].matchAll(/(\d+)([hms])/g)].reduce(
+        (sum, match) => sum + Number(match[1]) * units[match[2]],
+        0,
+    );
+    const resetAt = now + duration;
+    return duration > 0 && Number.isSafeInteger(resetAt) && resetAt < 8.64e15 ? resetAt : undefined;
+}
+
+function finiteTokenCount(value: unknown): number | null {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+}
+
+function completionShape(value: unknown): AssistantCompletionShape | null {
+    if (!isRecord(value)) return null;
+    const info = isRecord(value.info) ? value.info : value;
+    if (info.role !== "assistant") return null;
+
+    const time = isRecord(info.time) ? info.time : null;
+    const tokens = isRecord(info.tokens) ? info.tokens : null;
+    return {
+        createdAt: typeof time?.created === "number" ? time.created : 0,
+        finish:
+            typeof info.finish === "string"
+                ? info.finish
+                : typeof info.finish_reason === "string"
+                  ? info.finish_reason
+                  : typeof info.finishReason === "string"
+                    ? info.finishReason
+                    : null,
+        error: info.error,
+        outputTokens: finiteTokenCount(tokens?.output),
+        reasoningTokens: finiteTokenCount(tokens?.reasoning),
+    };
+}
+
+function latestAssistantCompletion(messages: unknown): AssistantCompletionShape | null {
+    if (!Array.isArray(messages)) return null;
+    let latest: AssistantCompletionShape | null = null;
+    for (const message of messages) {
+        const completion = completionShape(message);
+        if (completion && (!latest || completion.createdAt >= latest.createdAt))
+            latest = completion;
+    }
+    return latest;
+}
+
+/**
+ * OpenCode can serialize a provider outage as a successful `finish=stop` assistant
+ * message. Only classify that shape after manifest validation has already failed:
+ * a real manifest remains authoritative regardless of its token counts.
+ */
+export function providerOutputFailureFromInvalidManifest(
+    messages: unknown,
+    responseText: string,
+    now = Date.now(),
+): ProviderOutputFailureError | null {
+    const completion = latestAssistantCompletion(messages);
+    if (completion?.finish?.toLowerCase() !== "stop") return null;
+    if (
+        completion.error != null ||
+        completion.outputTokens === null ||
+        completion.reasoningTokens !== 0
+    ) {
+        return null;
+    }
+
+    const normalized = responseText.trim().replace(/\s+/g, " ").toLowerCase();
+    if (!normalized) return null;
+    const resetAt = quotaResetAt(responseText, now);
+    if (resetAt === undefined && completion.outputTokens > MAX_NEAR_ZERO_OUTPUT_TOKENS) return null;
+    const fingerprint = createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+    return new ProviderOutputFailureError(
+        fingerprint,
+        completion.outputTokens,
+        completion.reasoningTokens,
+        responseText,
+        resetAt,
+    );
+}

package/src/shared/sqlite-acquisition-routing.test.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
     Database,
+    SqliteAcquisitionBusyError,
     withAsyncPrivilegedWriter,
     withPrivilegedWriter,
     withSqliteTransformPass,
@@ -11,6 +12,23 @@ import {
 import { startSqliteWriteLocker } from "./sqlite-write-locker-test-support";
 import { createTestTempDirFromPath } from "./test-temp-dir";
 
+test("async writer never retries callback acquisition errors after work began", async () => {
+    const db = new Database(":memory:");
+    db.exec("CREATE TABLE context_privilege_state(id INTEGER PRIMARY KEY, enabled INTEGER)");
+    let calls = 0;
+    try {
+        await expect(
+            withAsyncPrivilegedWriter(db, () => {
+                calls++;
+                throw new SqliteAcquisitionBusyError(new Error("nested BEGIN"));
+            }),
+        ).rejects.toThrow("acquisition remained busy");
+        expect(calls).toBe(1);
+    } finally {
+        db.close();
+    }
+});
+
 for (const mode of ["default", "immediate", "exclusive", "literal"] as const) {
     test(`shared SQLite retries ${mode} acquisition before running any writes`, async () => {
         const dir = createTestTempDirFromPath(join(tmpdir(), "mc-routed-acquisition-"));

package/src/shared/sqlite.ts

@@ -245,6 +245,7 @@ function installTransactionRouting(db: BetterSqlite3.Database, readonly: boolean
         configurable: true,
         writable: true,
         value: (sql: string) => {
+            if (/^\s*(?:COMMIT|END)\b/i.test(sql)) assertTransformWrite();
             if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
                 // A transaction that ended without passing through exec (for
                 // example an automatic rollback) must not be timed as this one.
@@ -556,6 +557,33 @@ interface StatementOwner {
 const statementOwners = new WeakMap<Database, StatementOwner>();
 const FIRST_PRUNE_AT = 256;
 
+/**
+ * Bun's default close (`sqlite3_close_v2`) only releases the native connection
+ * once every statement created by prepare() is finalized. The close override
+ * in ownPreparedStatement can finalize only statements that are still
+ * reachable. Once the garbage collector
+ * has marked a one-shot statement dead, its weak reference is already cleared,
+ * but the statement is finalized only when its memory is later swept. Until
+ * then the closed connection keeps the database, WAL and shared-memory files
+ * open, for an unbounded time.
+ *
+ * `close(true)` finalizes every outstanding statement, reachable or not, and
+ * releases the connection immediately. When the caller did not ask for errors
+ * and that close fails, fall back to the caller's own close so a teardown path
+ * never starts throwing; the fallback can defer the release as before.
+ */
+function closeReleasingStatements(
+    close: (...args: unknown[]) => unknown,
+    args: unknown[],
+): unknown {
+    if (args[0] === true) return close(true);
+    try {
+        return close(true);
+    } catch {
+        return close(...args);
+    }
+}
+
 function ownPreparedStatement(db: Database, statement: Statement): Statement {
     const finalizable = statement as FinalizableStatement;
     // Node finalizes its statements on close and exposes no finalize() method.
@@ -579,7 +607,7 @@ function ownPreparedStatement(db: Database, statement: Statement): Statement {
                     }
                 }
                 references.clear();
-                const result = close(...args);
+                const result = closeReleasingStatements(close, args);
                 if (failure) throw failure;
                 return result;
             },
@@ -617,7 +645,12 @@ export function prepareCachedStatement(db: Database, sql: string): Statement {
 
 const privilegeDepth = new WeakMap<Database, number>();
 const transformPassScope = new AsyncLocalStorage<
-    { active: boolean; remainingWaitMs: number } | undefined
+    | {
+          active: boolean;
+          remainingWaitMs: number;
+          guard?: { assert(): void; remainingMs(): number };
+      }
+    | undefined
 >();
 const admissionScope = new AsyncLocalStorage<boolean>();
 const backgroundWriterScope = new AsyncLocalStorage<boolean>();
@@ -655,6 +688,17 @@ export function withoutSqliteTransformPass<T>(operation: () => T): T {
     return transformPassScope.run(undefined, operation);
 }
 
+/** Attach the adapter's existing generation/cancellation/deadline guard to writes. */
+export function guardSqliteTransformPass(guard: { assert(): void; remainingMs(): number }): void {
+    const lease = transformPassScope.getStore();
+    if (lease) lease.guard = guard;
+}
+
+/** Check the attached generation/cancellation/deadline guard before SQL or cache publication. */
+export function assertTransformWrite(): void {
+    if (!backgroundWriterScope.getStore()) transformPassScope.getStore()?.guard?.assert();
+}
+
 /** Bun names SQLite codes; node:sqlite exposes the numeric (possibly extended) errcode. */
 export function isTransientSqliteError(error: unknown): boolean {
     if (!error || typeof error !== "object") return false;
@@ -698,6 +742,7 @@ interface WriterAcquisition {
     startedAt: number;
     attempts: number;
     claimed: boolean;
+    remainingMs?: () => number;
 }
 
 /** A write transaction whose BEGIN went through `acquireShort` and has not ended yet. */
@@ -724,6 +769,7 @@ function foregroundWaitLease() {
  * native API cannot separate lock waiting from statement execution. Exhaustion
  * switches to zero-wait acquisition, not a refusal when the writer is free. */
 function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
+    assertTransformWrite();
     const lease = foregroundWaitLease();
     if (isInTransaction(db) || (!lease && !backgroundWriterScope.getStore())) return operation();
     const previous = pragmaNumber(db, "busy_timeout");
@@ -749,6 +795,7 @@ function withAutocommitTimeout<T>(db: Database, operation: () => T): T {
 
 /** The connection is never handed back to another caller with a shortened timeout. */
 function acquireShort(db: Database, acquire: () => unknown, site: string): void {
+    assertTransformWrite();
     const started = performance.now();
     const previous = pragmaNumber(db, "busy_timeout");
     const outer = writerAcquisitionScope.getStore();
@@ -763,7 +810,12 @@ function acquireShort(db: Database, acquire: () => unknown, site: string): void
         // stays short. An ordinary BEGIN inside a transform pass cannot yield;
         // give that single attempt enough time for a brief writer to finish.
         const lease = foregroundWaitLease();
-        const timeout = lease ? Math.floor(lease.remainingWaitMs) : SHORT_BUSY_TIMEOUT_MS;
+        const timeout = Math.floor(
+            Math.min(
+                lease ? lease.remainingWaitMs : SHORT_BUSY_TIMEOUT_MS,
+                owner?.remainingMs?.() ?? lease?.guard?.remainingMs() ?? Infinity,
+            ),
+        );
         db.exec(`PRAGMA busy_timeout=${timeout}`);
         acquire();
         acquiredAt = performance.now();
@@ -871,11 +923,28 @@ export async function beginSqliteWriterAsync(db: Database, site: string): Promis
 }
 
 /** Retry admission before any turn work, yielding between short lock attempts. */
-export async function withAsyncPrivilegedWriter<T>(db: Database, operation: () => T): Promise<T> {
+export async function withAsyncPrivilegedWriter<T>(
+    db: Database,
+    operation: () => T,
+    options: {
+        signal?: AbortSignal;
+        beforeRetry?: (error: SqliteAcquisitionBusyError) => void;
+        jitter?: boolean;
+        budgetMs?: number;
+        assertCurrentPass?: () => void;
+    } = {},
+): Promise<T> {
     const started = performance.now();
+    const budgetMs = Math.max(
+        0,
+        Math.min(FOREGROUND_ACQUISITION_BUDGET_MS, options.budgetMs ?? Infinity),
+    );
     let attempts = 0;
     for (;;) {
+        options.signal?.throwIfAborted();
+        options.assertCurrentPass?.();
         attempts++;
+        let entered = false;
         try {
             const acquisition: WriterAcquisition = {
                 site: "privileged_writer",
@@ -883,35 +952,51 @@ export async function withAsyncPrivilegedWriter<T>(db: Database, operation: () =
                 startedAt: started,
                 attempts,
                 claimed: false,
+                remainingMs: () => Math.max(0, budgetMs - (performance.now() - started)),
             };
             // The acquisition and hold of this transaction are reported when it
             // commits or rolls back (see endWriterTransaction).
             return admissionScope.run(true, () =>
                 withSqliteTransformPass(() =>
                     writerAcquisitionScope.run(acquisition, () =>
-                        withPrivilegedWriter(db, operation),
+                        withPrivilegedWriter(db, () => {
+                            entered = true;
+                            return operation();
+                        }),
                     ),
                 ),
             );
         } catch (error) {
             // A callback failure can occur after writes; only retry a failed BEGIN.
-            if (!(error instanceof SqliteAcquisitionBusyError)) throw error;
+            if (entered || !(error instanceof SqliteAcquisitionBusyError)) throw error;
+            // Adapters may serve a validated saved request instead of waiting.
+            // This runs only after a failed BEGIN, never after callback writes.
+            options.beforeRetry?.(error);
             const elapsed = performance.now() - started;
-            if (elapsed >= FOREGROUND_ACQUISITION_BUDGET_MS) {
+            if (elapsed >= budgetMs) {
                 reportSqliteDiagnostic(
                     `sqlite writer site=privileged_writer lane=foreground acquire_ms=${Math.round(elapsed)} attempts=${attempts} outcome=busy`,
                 );
                 throw error;
             }
-            await new Promise<void>((resolve) =>
-                setTimeout(
-                    resolve,
-                    Math.min(
-                        attempts === 1 ? 500 : 1000,
-                        FOREGROUND_ACQUISITION_BUDGET_MS - elapsed,
-                    ),
-                ),
+            const backoff = attempts === 1 ? 500 : 1000;
+            const delay = Math.min(
+                options.jitter ? backoff * (0.8 + Math.random() * 0.4) : backoff,
+                budgetMs - elapsed,
             );
+            await new Promise<void>((resolve, reject) => {
+                const abort = () => {
+                    clearTimeout(timer);
+                    options.signal?.removeEventListener("abort", abort);
+                    reject(options.signal?.reason ?? new Error("Writer wait aborted"));
+                };
+                const timer = setTimeout(() => {
+                    options.signal?.removeEventListener("abort", abort);
+                    resolve();
+                }, delay);
+                options.signal?.addEventListener("abort", abort, { once: true });
+                if (options.signal?.aborted) abort();
+            });
         }
     }
 }

package/src/shared/status-detail-text.test.ts

@@ -92,7 +92,7 @@ describe("status detail text", () => {
         expect(formatStatusDetailMarkdown(STATUS_FIXTURE)).toBe(`## Magic Context Status
 
 - **Context:** 75.0% of usable context (96,000 / 128,000 tokens)
-- **Cache lifetime:** 1h (config for anthropic/claude-opus-5)
+- **Cache lifetime:** 1h (your config)
 - **Automatic compression:** at 65.0% of usable context
 - **History compression:** Compressing history · 12 history blocks
 - **Reclaimable:** 3 spent tool outputs (~14k tokens)

package/src/shared/status-view.test.ts

@@ -256,7 +256,7 @@ describe("status view model", () => {
      * gap fit; otherwise the caller draws one column.
      */
     test("draws two columns only when both columns' values fit", () => {
-        const sections = view().sections;
+        const sections = view({ cacheTtlSource: "default" }).sections;
         for (const section of sections) {
             const longest = Math.max(...section.rows.map((row) => row.value.length));
             expect(statusSectionWidth(section)).toBe(section.labelWidth + 1 + longest);

package/src/shared/temporal-upgrade-fixture.ts

@@ -0,0 +1,50 @@
+import fixture from "../../../../testdata/temporal-upgrade-projections.json";
+import type { Database } from "./sqlite";
+
+export type TemporalFixtureRuntime = "Pi" | "OpenCode 1" | "OpenCode 2";
+type Value = null | string | number | { base64: string };
+interface CapturedSession {
+    sessionId: string;
+    cwd?: string;
+    input: unknown[];
+    entryIds?: string[];
+    projection: unknown[];
+    projectionJson: string;
+    state: Record<string, Array<Record<string, Value>>>;
+}
+
+export const temporalUpgradeCases: Record<TemporalFixtureRuntime, CapturedSession> = fixture.cases;
+
+/** Restore old served state, never by first rendering it with the current code. */
+export function seedTemporalUpgradeFixture(
+    db: Database,
+    runtime: TemporalFixtureRuntime,
+): CapturedSession {
+    const captured = temporalUpgradeCases[runtime];
+    db.transaction(() => {
+        for (const [table, rows] of Object.entries(captured.state)) {
+            for (const row of rows) {
+                const columns = Object.keys(row);
+                const values = Object.values(row).map((value) =>
+                    value !== null && typeof value === "object"
+                        ? Buffer.from(value.base64, "base64")
+                        : value,
+                );
+                db.prepare(
+                    `INSERT INTO ${table} (${columns.join(",")}) VALUES (${columns.map(() => "?").join(",")})`,
+                ).run(...values);
+            }
+        }
+        // Advance only the cache clock: timestamp-derived marker bytes and
+        // the old input/projection are the immutable captured fixture.
+        db.prepare("UPDATE session_meta SET last_response_time=? WHERE session_id=?").run(
+            Date.now(),
+            captured.sessionId,
+        );
+        db.prepare("UPDATE lkg_slots SET captured_at=? WHERE session_id=?").run(
+            Date.now(),
+            captured.sessionId,
+        );
+    }).immediate();
+    return captured;
+}

package/src/shared/window-geometry.ts

@@ -89,6 +89,8 @@ export interface WindowDerivation {
     geometry: WindowGeometry;
     windowSource: WindowLimitSource;
     absoluteWall: number;
+    /** Accepted provider input used to raise the usable denominator above metadata. */
+    provenInputTokens?: number;
 }
 
 export interface WindowGeometryResult {
@@ -691,6 +693,7 @@ export function applyProvenInputFloor(
                 absoluteWall: trustedAbsoluteWall
                     ? geometry.derivation.absoluteWall
                     : Math.max(geometry.derivation.absoluteWall, provenInputTokens),
+                provenInputTokens,
             },
         },
     };
@@ -715,6 +718,13 @@ export function formatWindowDerivationLine(
     return `${formatCompactTokens(inputTokens)} / ${formatCompactTokens(result.usableSoft)} usable · window ${formatCompactTokens(result.derivation.window)} · ${formatCompactTokens(result.derivation.reserve)} ${reserveLabel}`;
 }
 
+/** Distinguish metadata from a denominator raised by an accepted input measurement. */
+export function formatWindowSource(result: WindowGeometryResult | undefined): string {
+    return result?.derivation.provenInputTokens
+        ? `provider-measured floor (${result.derivation.windowSource})`
+        : (result?.derivation.windowSource ?? "unknown");
+}
+
 export function formatCompactTokens(value: number): string {
     if (Math.abs(value) >= 1_000_000) {
         return `${(value / 1_000_000).toFixed(1).replace(/\.0$/, "")}m`;

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

@@ -70,7 +70,7 @@ const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: stri
     },
     {
         path: "packages/pi-plugin/src/context-handler.ts",
-        sites: ["pi_compaction_queue"],
+        sites: ["pi_fallback_adoption"],
     },
 ];
 
@@ -116,7 +116,7 @@ const newlyCoveredSites = [
     "pi_materialize_cache",
     "pi_soft_refresh_cache",
     "pi_historian_publish",
-    "pi_compaction_queue",
+    "pi_fallback_adoption",
     "user_memory_candidate_insert",
 ] as const;
 

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

@@ -15,12 +15,36 @@ export function logSlowWriteTransaction(
     startedAt: number,
     thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS,
     completedAtMs = performance.now(),
+    steps?: Readonly<Record<string, number>>,
 ): void {
     try {
         const durationMs = completedAtMs - startedAt;
         if (durationMs < thresholdMs) return;
-        log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms`);
+        const detail = steps
+            ? Object.entries(steps)
+                  .map(([name, ms]) => `${name}=${ms.toFixed(1)}ms`)
+                  .join(" ")
+            : "";
+        log(
+            `[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms${detail ? ` ${detail}` : ""}`,
+        );
     } catch {
         // Timing diagnostics must never make a committed write appear to fail.
     }
 }
+
+/** Step durations include precomputation when named `pre_*`; held time never does. */
+export class WriteTransactionSteps {
+    readonly durations: Record<string, number> = {};
+    private last = performance.now();
+
+    mark(name: string): void {
+        const now = performance.now();
+        this.durations[name] = now - this.last;
+        this.last = now;
+    }
+
+    reset(): void {
+        this.last = performance.now();
+    }
+}

package/dist/features/magic-context/window-report-ledger.d.ts

@@ -1,70 +0,0 @@
-import type { ContextLimitProvenance } from "../../shared/context-limit-provenance";
-export declare const WINDOW_REPORTS_ROTATION_BYTES: number;
-/**
- * Fusiform's full-catalog dual-detector admit sweep (pm_d3e23fcd, 2026-08-13:
- * 125 providers / 5,680 models whose catalogs carry other vendors' models).
- * An ADMIT list, not a classification — membership warrants
- * `path_may_forward: true` at capture; absence clears nobody (a provider
- * using an id convention neither detector knows is silently missing here),
- * which is why the emitter never writes `false`: the report schema pins
- * absent = unknown routing (refuses promotion, same as true), while an
- * explicit false would PERMIT promotion — a claim this set structurally
- * cannot support.
- *
- * `ollama-cloud` is deliberately EXCLUDED: the detectors admit it (it
- * carries glm/deepseek/kimi weights) but it imposes its OWN wall from its
- * own serving stack — and this field marks whose-wall-might-fire, not
- * who-carries-whose-models. Other own-wall gateways may hide in this list;
- * only per-cell evidence distinguishes them, and Fusiform's adjudicator
- * refuses promotion for every admitted provider regardless, so a wrong
- * `true` here degrades toward refusal, never toward a wrong mint.
- */
-export declare const FORWARDING_PROVIDER_IDS: ReadonlySet<string>;
-export interface WindowReport {
-    provider_id?: string;
-    model_id?: string;
-    access_path: "api";
-    status?: number;
-    matched_pattern?: string;
-    extracted_limit?: number;
-    extracted_limit_units?: "provider";
-    attempted_tokens?: number;
-    attempted_tokens_units?: "estimate";
-    geometry: "prompt_only" | "combined" | "unknown";
-    observed_at_ms: number;
-    largest_success?: number;
-    largest_success_units?: "estimate";
-    /**
-     * Emitted ONLY as `true` (provider is a known forwarder) or omitted
-     * (unknown routing — refuses promotion by the schema's absent rule).
-     * Never `false`: this reporter has no evidence basis for asserting a
-     * path cannot forward, and explicit false is the one value that would
-     * permit promoting a measured report at a forwarded key.
-     */
-    path_may_forward?: true;
-    /** Observed routing evidence only; never inferred from provider configuration. */
-    served_by_hint?: string;
-}
-export interface AppendWindowReportInput {
-    db: import("../../shared/sqlite").Database;
-    providerID?: string;
-    modelID?: string;
-    matchedPattern?: string;
-    reportedLimit?: number;
-    reportedLimitProvenance?: ContextLimitProvenance;
-    attemptedTokens?: number;
-    error?: unknown;
-    observedAtMs?: number;
-    sessionID?: string;
-}
-export interface WindowReportLedgerDiagnostics {
-    swallowedWriteCount: number;
-    lastErrorMessage: string | null;
-}
-export declare function getWindowReportsPath(): string;
-export declare function getWindowReportLedgerDiagnostics(): WindowReportLedgerDiagnostics;
-export declare function __resetWindowReportLedgerDiagnosticsForTests(): void;
-export declare function buildWindowReport(input: AppendWindowReportInput): WindowReport;
-export declare function appendWindowReport(report: WindowReport): void;
-export declare function captureWindowReport(input: AppendWindowReportInput): void;
-//# sourceMappingURL=window-report-ledger.d.ts.map

package/dist/features/magic-context/window-report-ledger.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"window-report-ledger.d.ts","sourceRoot":"","sources":["../../../src/features/magic-context/window-report-ledger.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AASpF,eAAO,MAAM,6BAA6B,QAAmB,CAAC;AAE9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CA6HtD,CAAC;AAEH,MAAM,WAAW,YAAY;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,KAAK,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,UAAU,CAAC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,sBAAsB,CAAC,EAAE,UAAU,CAAC;IACpC,QAAQ,EAAE,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qBAAqB,CAAC,EAAE,UAAU,CAAC;IACnC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,IAAI,CAAC;IACxB,kFAAkF;IAClF,cAAc,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,OAAO,qBAAqB,EAAE,QAAQ,CAAC;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uBAAuB,CAAC,EAAE,sBAAsB,CAAC;IACjD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,6BAA6B;IAC1C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;CACnC;AAKD,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAYD,wBAAgB,gCAAgC,IAAI,6BAA6B,CAEhF;AAED,wBAAgB,4CAA4C,IAAI,IAAI,CAGnE;AA2ED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,uBAAuB,GAAG,YAAY,CAqC9E;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAmB7D;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,uBAAuB,GAAG,IAAI,CAMxE"}

package/dist/index-e1q8002h.js

@@ -1,16 +0,0 @@
-import {
-  log
-} from "./index-qbkzdkk0.js";
-
-// src/shared/write-transaction-timing.ts
-var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;
-function logSlowWriteTransaction(site, startedAt, thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS, completedAtMs = performance.now()) {
-  try {
-    const durationMs = completedAtMs - startedAt;
-    if (durationMs < thresholdMs)
-      return;
-    log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms`);
-  } catch {}
-}
-
-export { logSlowWriteTransaction };