@ltm-alpha/alpha-cs 1.6.0

package/dist/db/wal-valve.d.ts

@@ -0,0 +1,139 @@
+/**
+ * WAL checkpoint valve — bounds WAL growth while auto-checkpointing is
+ * deferred during a bulk index (#1231).
+ *
+ * Why deferral: SQLite's default `wal_autocheckpoint` (1000 pages) re-writes
+ * hot B-tree/FTS pages into the main DB file over and over during a bulk
+ * index — measured at ~95% of ALL disk I/O, and the difference between 45s
+ * and 19+ minutes on HDD-class storage (150 random IOPS). Deferring
+ * checkpoints turns the store into pure sequential WAL appends; each backfill
+ * pass writes distinct pages once, in page order (≈ sequential).
+ *
+ * Why a valve: unbounded deferral is its own failure mode, both measured in
+ * the #1231 repro. The WAL duplicates hot pages per COMMIT, so it grows far
+ * faster than the DB (5.9GB WAL for a ~340MB DB on a 3.3k-file index) —
+ * filling the disk, and poisoning every subsequent read that must page
+ * through it (the first resolution-phase read blocked the main thread >60s
+ * and the #850 liveness watchdog killed the healthy index). The valve
+ * watches WAL growth on a timer and, past a soft threshold, backfills with
+ * `PRAGMA wal_checkpoint(PASSIVE)` on a worker-thread connection — PASSIVE
+ * never blocks the writer, and off-thread means the main thread (and the
+ * watchdog heartbeat) keep turning regardless of how long a backfill takes.
+ *
+ * The load-bearing subtlety: a WAL file's SIZE never shrinks. After a full
+ * backfill, the writer's next commit RESTARTS the WAL from the top and the
+ * frames recycle inside the same file — so raw size says nothing about the
+ * un-backfilled backlog, and a size-triggered valve degenerates into firing
+ * (and pausing the writer) forever once the file passes its threshold
+ * (measured: guava crawled at ~9min per 160 files). Instead the valve
+ * tracks `sizeAtLastFullBackfill` — refreshed whenever a checkpoint reports
+ * `log === checkpointed` (everything backfilled) — and triggers on GROWTH
+ * beyond that baseline, which only happens when genuinely un-backfilled
+ * frames push past the file's high-water mark.
+ *
+ * Backpressure: if the writer outruns the checkpointer past a hard cap of
+ * growth (2× soft), {@link backpressure} pauses the writer (at a safe,
+ * between-transactions boundary) until a FULL backfill lands. One in-flight
+ * pass is not enough: on a disk saturated by the writer, every concurrent
+ * PASSIVE pass is already stale by the time it finishes (the writer appended
+ * past its snapshot), so neither SQLite's WAL wrap nor the baseline ever
+ * trigger and the WAL grows without bound (measured: 5.9GB on guava at 150
+ * IOPS, then a >60s read stall and a watchdog kill). With the writer parked,
+ * the next pass covers everything, the WAL wraps on the following commit,
+ * and the pause is the disk's honest catch-up cost — the correct terminal
+ * mode when hardware genuinely can't keep up with the append rate.
+ *
+ * Fail-closed (#1539): if parked backfills cannot progress (a reader pinning
+ * frames) while the WAL is past the hard/file caps, the valve throws
+ * {@link WalValveAbortError} instead of releasing the writer. The previous
+ * "futility latch" disabled parking for 60s after consecutive give-ups so a
+ * pinned reader would not churn checkpoint workers — but that also let the
+ * WAL grow without a bound (observed 64 GiB on a kernel-scale daemon catch-up
+ * with the query pool holding read marks). Aborting with a clear error is the
+ * safe terminal mode; the caller closes readers / retries once the pin clears.
+ */
+import type { DatabaseConnection } from './index';
+/**
+ * Thrown when the valve cannot checkpoint past its documented caps while a
+ * reader pins WAL frames (#1539). Callers (index/sync) should surface this and
+ * stop writing rather than risk unbounded disk growth.
+ */
+export declare class WalValveAbortError extends Error {
+    readonly code: "WAL_VALVE_ABORT";
+    readonly walBytes: number;
+    readonly fileCapBytes: number;
+    readonly hardBytes: number;
+    constructor(message: string, sizes: {
+        walBytes: number;
+        fileCapBytes: number;
+        hardBytes: number;
+    });
+}
+/**
+ * Resolve the valve's soft threshold from the `CODEGRAPH_WAL_VALVE_MB`
+ * override; non-numeric / non-positive values fall back to the default.
+ */
+export declare function resolveWalValveMb(envVal: string | undefined, dbSizeBytes?: number): number;
+export declare class WalCheckpointValve {
+    private readonly db;
+    private readonly intervalMs;
+    private timer;
+    private inflight;
+    /** Writer pause in progress (hard cap breached): passes loop until a full backfill. */
+    private pause;
+    /**
+     * WAL file size observed when a checkpoint last reported the ENTIRE WAL
+     * backfilled. Growth is measured against this baseline — see the header
+     * comment for why absolute size cannot be used.
+     */
+    private sizeAtLastFullBackfill;
+    private readonly softBytes;
+    private readonly hardBytes;
+    private readonly fileCapBytes;
+    /**
+     * Consecutive parked-backfill give-ups. Used only for diagnostics in the
+     * abort message — parking is never disabled (#1539 fail-closed).
+     */
+    private consecutiveGiveUps;
+    constructor(db: DatabaseConnection, softMb?: number, intervalMs?: number, log?: (msg: string) => void);
+    private readonly log;
+    private mb;
+    /** Un-backfilled growth estimate: bytes the WAL has grown past the last full backfill. */
+    private growthBytes;
+    /** Begin watching the WAL. Idempotent; the timer never holds the loop open. */
+    start(): void;
+    /** Stop watching. Any in-flight checkpoint keeps running — await drain(). */
+    stop(): void;
+    /** One poll: fire an off-thread passive checkpoint when growth passes the soft threshold. */
+    check(): void;
+    /**
+     * Writer-side backstop, called at a between-transactions boundary. Returns
+     * null (no wait) while growth is under the hard cap; past it, returns a
+     * promise that resolves only once a FULL backfill has landed — see the
+     * header comment for why a single pass is not enough on a saturated disk.
+     */
+    backpressure(): Promise<void> | null;
+    /** Await any in-flight checkpoint and writer pause. */
+    drain(): Promise<void>;
+    /**
+     * Phase-boundary fold: backfill the ENTIRE WAL now (off-thread, awaited).
+     * Called between bulk phases — e.g. after parsing, before resolution's
+     * first reads — so the next phase never pages a bulk-write-sized WAL on
+     * the main thread (the post-parse read against a multi-GB WAL is what
+     * blew the #850 watchdog's 60s window in the #1231 repro). The await
+     * keeps the event loop (and the watchdog heartbeat) turning.
+     */
+    foldNow(): Promise<void>;
+    /**
+     * With the writer parked on the returned promise, loop passive passes until
+     * one reports the entire WAL backfilled (typically the second: the first
+     * drains the pass that was already running against a stale snapshot). After
+     * a bounded number of passes without a full backfill — e.g. a reader
+     * pinning the WAL — throws {@link WalValveAbortError} when still past the
+     * hard/file caps (#1539 fail-closed). Soft give-up under those caps is
+     * reserved for foldNow on a modest backlog that could not complete.
+     */
+    private backfillFully;
+    private fire;
+}
+//# sourceMappingURL=wal-valve.d.ts.map

package/dist/db/wal-valve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wal-valve.d.ts","sourceRoot":"","sources":["../../src/db/wal-valve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAElD;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAG,iBAAiB,CAAU;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;CAOlG;AAaD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAc1F;AAED,qBAAa,kBAAkB;IAsB3B,OAAO,CAAC,QAAQ,CAAC,EAAE;IAEnB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAvB7B,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,QAAQ,CAA8B;IAC9C,uFAAuF;IACvF,OAAO,CAAC,KAAK,CAA8B;IAC3C;;;;OAIG;IACH,OAAO,CAAC,sBAAsB,CAAK;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IAEtC;;;OAGG;IACH,OAAO,CAAC,kBAAkB,CAAK;gBAGZ,EAAE,EAAE,kBAAkB,EACvC,MAAM,GAAE,MAA8D,EACrD,UAAU,GAAE,MAA0B,EACvD,GAAG,GAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAe;IAavC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAwB;IAE5C,OAAO,CAAC,EAAE;IAIV,0FAA0F;IAC1F,OAAO,CAAC,WAAW;IAInB,+EAA+E;IAC/E,KAAK,IAAI,IAAI;IAkBb,6EAA6E;IAC7E,IAAI,IAAI,IAAI;IAOZ,6FAA6F;IAC7F,KAAK,IAAI,IAAI;IAIb;;;;;OAKG;IACH,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI;IAoBpC,uDAAuD;IACjD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B;;;;;;;OAOG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ9B;;;;;;;;OAQG;YACW,aAAa;IAgE3B,OAAO,CAAC,IAAI;CA8Bb"}

package/dist/db/wal-valve.js

@@ -0,0 +1,333 @@
+"use strict";
+/**
+ * WAL checkpoint valve — bounds WAL growth while auto-checkpointing is
+ * deferred during a bulk index (#1231).
+ *
+ * Why deferral: SQLite's default `wal_autocheckpoint` (1000 pages) re-writes
+ * hot B-tree/FTS pages into the main DB file over and over during a bulk
+ * index — measured at ~95% of ALL disk I/O, and the difference between 45s
+ * and 19+ minutes on HDD-class storage (150 random IOPS). Deferring
+ * checkpoints turns the store into pure sequential WAL appends; each backfill
+ * pass writes distinct pages once, in page order (≈ sequential).
+ *
+ * Why a valve: unbounded deferral is its own failure mode, both measured in
+ * the #1231 repro. The WAL duplicates hot pages per COMMIT, so it grows far
+ * faster than the DB (5.9GB WAL for a ~340MB DB on a 3.3k-file index) —
+ * filling the disk, and poisoning every subsequent read that must page
+ * through it (the first resolution-phase read blocked the main thread >60s
+ * and the #850 liveness watchdog killed the healthy index). The valve
+ * watches WAL growth on a timer and, past a soft threshold, backfills with
+ * `PRAGMA wal_checkpoint(PASSIVE)` on a worker-thread connection — PASSIVE
+ * never blocks the writer, and off-thread means the main thread (and the
+ * watchdog heartbeat) keep turning regardless of how long a backfill takes.
+ *
+ * The load-bearing subtlety: a WAL file's SIZE never shrinks. After a full
+ * backfill, the writer's next commit RESTARTS the WAL from the top and the
+ * frames recycle inside the same file — so raw size says nothing about the
+ * un-backfilled backlog, and a size-triggered valve degenerates into firing
+ * (and pausing the writer) forever once the file passes its threshold
+ * (measured: guava crawled at ~9min per 160 files). Instead the valve
+ * tracks `sizeAtLastFullBackfill` — refreshed whenever a checkpoint reports
+ * `log === checkpointed` (everything backfilled) — and triggers on GROWTH
+ * beyond that baseline, which only happens when genuinely un-backfilled
+ * frames push past the file's high-water mark.
+ *
+ * Backpressure: if the writer outruns the checkpointer past a hard cap of
+ * growth (2× soft), {@link backpressure} pauses the writer (at a safe,
+ * between-transactions boundary) until a FULL backfill lands. One in-flight
+ * pass is not enough: on a disk saturated by the writer, every concurrent
+ * PASSIVE pass is already stale by the time it finishes (the writer appended
+ * past its snapshot), so neither SQLite's WAL wrap nor the baseline ever
+ * trigger and the WAL grows without bound (measured: 5.9GB on guava at 150
+ * IOPS, then a >60s read stall and a watchdog kill). With the writer parked,
+ * the next pass covers everything, the WAL wraps on the following commit,
+ * and the pause is the disk's honest catch-up cost — the correct terminal
+ * mode when hardware genuinely can't keep up with the append rate.
+ *
+ * Fail-closed (#1539): if parked backfills cannot progress (a reader pinning
+ * frames) while the WAL is past the hard/file caps, the valve throws
+ * {@link WalValveAbortError} instead of releasing the writer. The previous
+ * "futility latch" disabled parking for 60s after consecutive give-ups so a
+ * pinned reader would not churn checkpoint workers — but that also let the
+ * WAL grow without a bound (observed 64 GiB on a kernel-scale daemon catch-up
+ * with the query pool holding read marks). Aborting with a clear error is the
+ * safe terminal mode; the caller closes readers / retries once the pin clears.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalCheckpointValve = exports.WalValveAbortError = void 0;
+exports.resolveWalValveMb = resolveWalValveMb;
+/**
+ * Thrown when the valve cannot checkpoint past its documented caps while a
+ * reader pins WAL frames (#1539). Callers (index/sync) should surface this and
+ * stop writing rather than risk unbounded disk growth.
+ */
+class WalValveAbortError extends Error {
+    code = 'WAL_VALVE_ABORT';
+    walBytes;
+    fileCapBytes;
+    hardBytes;
+    constructor(message, sizes) {
+        super(message);
+        this.name = 'WalValveAbortError';
+        this.walBytes = sizes.walBytes;
+        this.fileCapBytes = sizes.fileCapBytes;
+        this.hardBytes = sizes.hardBytes;
+    }
+}
+exports.WalValveAbortError = WalValveAbortError;
+/** Soft WAL-growth threshold (MB) that triggers an off-thread passive checkpoint. */
+const DEFAULT_WAL_VALVE_MB = 256;
+/** Hard cap = this × soft threshold; past it the writer pauses for a full backfill. */
+const HARD_CAP_MULTIPLIER = 2;
+/** File cap = this × soft threshold; past it the barrier also TRUNCATEs the file. */
+const FILE_CAP_MULTIPLIER = 4;
+/** Passes attempted per writer pause before giving up (a pinned reader could stall forever). */
+const MAX_PAUSED_BACKFILL_PASSES = 20;
+/** How often the timer looks at the WAL file size. */
+const CHECK_INTERVAL_MS = 2000;
+/**
+ * Resolve the valve's soft threshold from the `CODEGRAPH_WAL_VALVE_MB`
+ * override; non-numeric / non-positive values fall back to the default.
+ */
+function resolveWalValveMb(envVal, dbSizeBytes) {
+    if (envVal !== undefined && envVal !== '') {
+        const n = Number(envVal);
+        if (Number.isFinite(n) && n > 0)
+            return Math.floor(n);
+    }
+    // Scale with the project when the caller knows the DB size: every fold
+    // re-writes hot B-tree pages into the main file (the #1231 pathology in
+    // bounded form — 111s of a kernel-scale batch loop at the flat 256MB cap,
+    // §7a.2), so a big project affords a proportionally bigger transient WAL
+    // (~dbSize/4 soft ⇒ file cap ≈ dbSize) in exchange for ~4× fewer folds.
+    if (dbSizeBytes !== undefined && dbSizeBytes > 0) {
+        return Math.min(2048, Math.max(DEFAULT_WAL_VALVE_MB, Math.floor(dbSizeBytes / 4 / (1024 * 1024))));
+    }
+    return DEFAULT_WAL_VALVE_MB;
+}
+class WalCheckpointValve {
+    db;
+    intervalMs;
+    timer = null;
+    inflight = null;
+    /** Writer pause in progress (hard cap breached): passes loop until a full backfill. */
+    pause = null;
+    /**
+     * WAL file size observed when a checkpoint last reported the ENTIRE WAL
+     * backfilled. Growth is measured against this baseline — see the header
+     * comment for why absolute size cannot be used.
+     */
+    sizeAtLastFullBackfill = 0;
+    softBytes;
+    hardBytes;
+    fileCapBytes;
+    /**
+     * Consecutive parked-backfill give-ups. Used only for diagnostics in the
+     * abort message — parking is never disabled (#1539 fail-closed).
+     */
+    consecutiveGiveUps = 0;
+    constructor(db, softMb = resolveWalValveMb(process.env.CODEGRAPH_WAL_VALVE_MB), intervalMs = CHECK_INTERVAL_MS, log = () => { }) {
+        this.db = db;
+        this.intervalMs = intervalMs;
+        this.softBytes = softMb * 1024 * 1024;
+        this.hardBytes = this.softBytes * HARD_CAP_MULTIPLIER;
+        this.fileCapBytes = this.softBytes * FILE_CAP_MULTIPLIER;
+        // CODEGRAPH_WAL_VALVE_DEBUG=1 surfaces valve decisions to stderr without
+        // needing the caller's verbose plumbing — the observability gap that let
+        // §7a.1 run 1 fail silently (give-ups were verbose-gated and invisible).
+        this.log = process.env.CODEGRAPH_WAL_VALVE_DEBUG
+            ? (m) => console.error(`[wal-valve] ${m}`)
+            : log;
+    }
+    log;
+    mb(n) {
+        return `${Math.round(n / 1024 / 1024)}MB`;
+    }
+    /** Un-backfilled growth estimate: bytes the WAL has grown past the last full backfill. */
+    growthBytes() {
+        return this.db.getWalSizeBytes() - this.sizeAtLastFullBackfill;
+    }
+    /** Begin watching the WAL. Idempotent; the timer never holds the loop open. */
+    start() {
+        if (this.timer)
+            return;
+        // One armed line per run under either diagnostics env: §7a.1's failed
+        // kernel-scale runs burned three 25-minute cycles before "is the valve
+        // even alive?" could be answered.
+        if (process.env.CODEGRAPH_SYNTH_TIMINGS || process.env.CODEGRAPH_WAL_VALVE_DEBUG) {
+            console.error(`[wal-valve] armed soft=${this.mb(this.softBytes)} hard=${this.mb(this.hardBytes)} wal=${this.mb(this.db.getWalSizeBytes())}`);
+        }
+        let ticks = 0;
+        this.timer = setInterval(() => {
+            if ((++ticks % 15) === 0) {
+                this.log(`alive: wal=${this.mb(this.db.getWalSizeBytes())} baseline=${this.mb(this.sizeAtLastFullBackfill)} inflight=${this.inflight ? 'y' : 'n'} paused=${this.pause ? 'y' : 'n'}`);
+            }
+            this.check();
+        }, this.intervalMs);
+        this.timer.unref?.();
+    }
+    /** Stop watching. Any in-flight checkpoint keeps running — await drain(). */
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /** One poll: fire an off-thread passive checkpoint when growth passes the soft threshold. */
+    check() {
+        if (!this.pause && !this.inflight && this.growthBytes() > this.softBytes)
+            this.fire();
+    }
+    /**
+     * Writer-side backstop, called at a between-transactions boundary. Returns
+     * null (no wait) while growth is under the hard cap; past it, returns a
+     * promise that resolves only once a FULL backfill has landed — see the
+     * header comment for why a single pass is not enough on a saturated disk.
+     */
+    backpressure() {
+        if (this.pause)
+            return this.pause;
+        // Two independent triggers:
+        //  - growth: un-backfilled BACKLOG past the hard cap (the original valve).
+        //  - file size: a WAL can stay fully backfilled and still grow without
+        //    bound — the writer only restarts at frame 0 if a commit finds no
+        //    reader marks, which §7a.1's instrumented run showed never happens
+        //    in practice (file marched 361→721MB through two COMPLETE
+        //    backfills). Past the file cap, park and TRUNCATE at the barrier —
+        //    the backfill part is instant when the backlog is already folded.
+        if (this.growthBytes() <= this.hardBytes && this.db.getWalSizeBytes() <= this.fileCapBytes)
+            return null;
+        this.log(`backpressure: wal=${this.mb(this.db.getWalSizeBytes())} baseline=${this.mb(this.sizeAtLastFullBackfill)} — pausing writer for full backfill`);
+        const t0 = Date.now();
+        this.pause = this.backfillFully().finally(() => {
+            this.pause = null;
+            this.log(`backpressure released after ${Date.now() - t0}ms: wal=${this.mb(this.db.getWalSizeBytes())} baseline=${this.mb(this.sizeAtLastFullBackfill)}`);
+        });
+        return this.pause;
+    }
+    /** Await any in-flight checkpoint and writer pause. */
+    async drain() {
+        while (this.pause || this.inflight) {
+            if (this.pause)
+                await this.pause;
+            if (this.inflight)
+                await this.inflight;
+        }
+    }
+    /**
+     * Phase-boundary fold: backfill the ENTIRE WAL now (off-thread, awaited).
+     * Called between bulk phases — e.g. after parsing, before resolution's
+     * first reads — so the next phase never pages a bulk-write-sized WAL on
+     * the main thread (the post-parse read against a multi-GB WAL is what
+     * blew the #850 watchdog's 60s window in the #1231 repro). The await
+     * keeps the event loop (and the watchdog heartbeat) turning.
+     */
+    async foldNow() {
+        await this.drain();
+        if (this.growthBytes() <= 0)
+            return;
+        this.log(`foldNow: wal=${this.mb(this.db.getWalSizeBytes())} baseline=${this.mb(this.sizeAtLastFullBackfill)}`);
+        this.pause = this.backfillFully().finally(() => { this.pause = null; });
+        await this.pause;
+    }
+    /**
+     * With the writer parked on the returned promise, loop passive passes until
+     * one reports the entire WAL backfilled (typically the second: the first
+     * drains the pass that was already running against a stale snapshot). After
+     * a bounded number of passes without a full backfill — e.g. a reader
+     * pinning the WAL — throws {@link WalValveAbortError} when still past the
+     * hard/file caps (#1539 fail-closed). Soft give-up under those caps is
+     * reserved for foldNow on a modest backlog that could not complete.
+     */
+    async backfillFully() {
+        for (let i = 0; i < MAX_PAUSED_BACKFILL_PASSES; i++) {
+            if (this.inflight)
+                await this.inflight; // fold in the stale in-flight pass first
+            const res = await this.db.checkpointWalPassive();
+            if (!res) {
+                // Machinery unavailable: fail closed past the documented caps (#1539),
+                // otherwise soft-return so a non-WAL / closing connection does not abort.
+                const walBytes = this.db.getWalSizeBytes();
+                const growth = this.growthBytes();
+                if (walBytes > this.fileCapBytes || growth > this.hardBytes) {
+                    throw new WalValveAbortError(`WAL checkpoint machinery unavailable while over the documented cap ` +
+                        `(wal=${this.mb(walBytes)}, fileCap=${this.mb(this.fileCapBytes)}). ` +
+                        `Aborting to avoid unbounded disk growth.`, { walBytes, fileCapBytes: this.fileCapBytes, hardBytes: this.hardBytes });
+                }
+                return;
+            }
+            this.log(`backfill pass ${i + 1}: busy=${res.busy} log=${res.log} checkpointed=${res.checkpointed} wal=${this.mb(this.db.getWalSizeBytes())}`);
+            if (res.busy === 0 && res.log === res.checkpointed) {
+                // Backfill complete AND we are at a parked barrier (backfillFully only
+                // runs under a writer pause): the no-reader window is guaranteed, so
+                // chop the FILE too — a fully-backfilled WAL otherwise keeps growing
+                // whenever commits land while pool readers hold marks (§7a.1: 22GB
+                // on-disk at kernel scale despite backfills). A racing reader turns
+                // this into a no-op (busy=1); the passive result above still stands.
+                const trunc = await this.db.checkpointWalTruncate();
+                if (trunc)
+                    this.log(`truncate: busy=${trunc.busy} wal=${this.mb(this.db.getWalSizeBytes())}`);
+                this.sizeAtLastFullBackfill = this.db.getWalSizeBytes();
+                this.consecutiveGiveUps = 0;
+                return;
+            }
+        }
+        this.consecutiveGiveUps++;
+        const walBytes = this.db.getWalSizeBytes();
+        const growth = this.growthBytes();
+        const msg = `backfill gave up after ${MAX_PAUSED_BACKFILL_PASSES} passes ` +
+            `(streak ${this.consecutiveGiveUps}) — a reader is pinning the WAL ` +
+            `(wal=${this.mb(walBytes)} growth=${this.mb(growth)} ` +
+            `hard=${this.mb(this.hardBytes)} fileCap=${this.mb(this.fileCapBytes)})`;
+        this.log(msg);
+        // Give-ups are rare and load-bearing for §7a.1-class diagnosis — surface
+        // them on any timing-instrumented run, not just valve-debug ones.
+        if (process.env.CODEGRAPH_SYNTH_TIMINGS && !process.env.CODEGRAPH_WAL_VALVE_DEBUG) {
+            console.error(`[wal-valve] ${msg}`);
+        }
+        // Fail closed (#1539): never release the writer past the documented caps
+        // when checkpoints cannot progress. The old futility latch disabled
+        // parking for 60s and allowed unbounded growth (64 GiB observed).
+        if (walBytes > this.fileCapBytes || growth > this.hardBytes) {
+            throw new WalValveAbortError(`WAL checkpoint cannot progress while a reader pins frames ` +
+                `(wal=${this.mb(walBytes)}, growth=${this.mb(growth)}, ` +
+                `fileCap=${this.mb(this.fileCapBytes)}, hard=${this.mb(this.hardBytes)}, ` +
+                `give-ups=${this.consecutiveGiveUps}). Aborting to avoid unbounded disk growth. ` +
+                `Close concurrent readers (for example the MCP query pool) and retry, ` +
+                `or raise CODEGRAPH_WAL_VALVE_MB if the threshold is too tight for this project.`, { walBytes, fileCapBytes: this.fileCapBytes, hardBytes: this.hardBytes });
+        }
+    }
+    fire() {
+        this.log(`fire: wal=${this.mb(this.db.getWalSizeBytes())} baseline=${this.mb(this.sizeAtLastFullBackfill)}`);
+        const p = this.db
+            .checkpointWalPassive()
+            .then((res) => {
+            this.log(`timer pass: ${res ? `busy=${res.busy} log=${res.log} checkpointed=${res.checkpointed}` : 'null (machinery unavailable)'} wal=${this.mb(this.db.getWalSizeBytes())}`);
+            // Full backfill (busy 0, every log frame checkpointed) ⇒ the writer's
+            // next commit wraps the WAL; the file's current size becomes the new
+            // growth baseline. A partial pass (writer appended during it, or a
+            // read transaction pinned frames) leaves the baseline alone, so the
+            // next tick fires again and copies the remainder. In non-WAL mode
+            // SQLite reports log = checkpointed = -1, which is harmless here.
+            if (res && res.busy === 0 && res.log === res.checkpointed) {
+                this.sizeAtLastFullBackfill = this.db.getWalSizeBytes();
+                // NO truncate here. A truncate checkpoint that starts against an
+                // ACTIVE writer wins the lock race and then blocks that writer for
+                // its entire backfill — after a multi-GB single-transaction burst
+                // (edge-index recreate) that exceeds the writer's 5s busy_timeout
+                // and fails the index with "database is locked" (§7a.2 record run).
+                // The file chop happens exclusively at parked barriers
+                // (backpressure/foldNow), where the writer is awaiting us by
+                // construction and cannot collide.
+            }
+        })
+            .catch(() => { })
+            .finally(() => {
+            if (this.inflight === p)
+                this.inflight = null;
+        });
+        this.inflight = p;
+    }
+}
+exports.WalCheckpointValve = WalCheckpointValve;
+//# sourceMappingURL=wal-valve.js.map

package/dist/db/wal-valve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wal-valve.js","sourceRoot":"","sources":["../../src/db/wal-valve.ts"],"names":[],"mappings":"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"}