@spikedpunch/mast 0.1.0

package/dist/store/lock.js

@@ -0,0 +1,182 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import lockfile from 'proper-lockfile';
+import { createFileLockMetricsSink } from './lockMetrics.js';
+const STALE_MS = 10_000;
+/**
+ * Thrown when the lock was taken away while this process still believed it
+ * held it — another process judged it stale and stole it, or the lock
+ * directory was removed underneath us.
+ *
+ * It is thrown at RELEASE, not when the compromise is detected, because
+ * proper-lockfile detects it inside an `fs.stat` callback on a timer: there is
+ * no caller on the stack to receive it there, which is exactly why the
+ * library's default handler (`onCompromised: (err) => { throw err; }`,
+ * `lib/lockfile.js`) reached the process as an uncaught exception and killed
+ * it — measured: `ECOMPROMISED ENOENT`, exit code 7, with no
+ * `uncaughtException` handler anywhere in `src`.
+ *
+ * **What this does and does not fix.** It converts a process kill into a
+ * failed operation the caller can retry, and it stops a run that was not
+ * exclusive from reporting success. It does NOT stop the work already in
+ * flight: by the time the compromise is detected, `fn` is mid-execution and
+ * nothing here can interrupt it. Doing that needs an `AbortSignal` threaded
+ * through `withLock` and honoured by every write phase, which is a design
+ * change, not a patch. The exposure is bounded: SQLite writes go through
+ * `populateFile`'s `BEGIN IMMEDIATE` transaction and stay serialised whatever
+ * this advisory lock believes, so what is actually at risk is the plain-JSON
+ * `file_manifest.json` / `index.json` writes this lock exists to coordinate —
+ * and a run that fails here is re-run, which rewrites both.
+ */
+export class LockCompromisedError extends Error {
+    /** The underlying proper-lockfile error (`ECOMPROMISED`). */
+    reason;
+    constructor(type, reason) {
+        super(`The ${type} lock was compromised while held — another process took it, so this run was ` +
+            `not exclusive and its result must not be trusted. Re-run the operation. Cause: ${String(reason)}`);
+        this.name = 'LockCompromisedError';
+        this.reason = reason;
+    }
+}
+/** Returns the path of the marker file that proper-lockfile uses as its lock target. */
+function markerPath(stateDir, type) {
+    return join(stateDir, type);
+}
+/**
+ * Ensure the marker files required by proper-lockfile exist in `stateDir`.
+ * Must be called during `mast init` before any lock can be acquired.
+ */
+export function initLockMarkers(stateDir) {
+    mkdirSync(stateDir, { recursive: true });
+    for (const type of ['structure']) {
+        writeFileSync(markerPath(stateDir, type), '', { flag: 'a' });
+    }
+}
+/**
+ * Acquire an advisory write lock for the given lock type.
+ *
+ * Returns a release function. Always `await release()` in a finally block.
+ * The returned function is wrapped to record hold-duration lock metrics on
+ * release — this covers direct callers as well as callers that go through
+ * {@link withLock}.
+ *
+ * Per spec §7.6:
+ * - CLI commands: maxRetries=1, retryIntervalMs=2000 (2s total)
+ * - mast_reindex / mast serve startup: maxRetries=5, retryIntervalMs=1000
+ *
+ * **F11 (`IMPLEMENTATION_PLAN.md` "Replace fail-fast advisory locking")
+ * narrowed this lock's role**: the JIT re-parse path (`mcp/staleness.ts`'s
+ * `checkAndRefreshIfStale`) no longer calls `acquireLock` at all — it relies
+ * on `populateFile`'s own `BEGIN IMMEDIATE` transaction
+ * (`graph/populate.ts`) plus a dedicated short `busy_timeout` instead. This
+ * lock is now acquired only by coarse writers: `mast index` / the startup
+ * reindex, `mast_reindex`, and the manifest/`index.json` phase (plain-JSON
+ * `writeFileSync`, which SQLite can never coordinate) — see `populateFile`'s
+ * doc comment for the full design rationale.
+ *
+ * @throws if the lock cannot be acquired after all retries.
+ */
+export async function acquireLock(stateDir, type, options = {}) {
+    const { maxRetries = 5, retryIntervalMs = 1_000, caller = 'unknown', sink = createFileLockMetricsSink(stateDir), staleMs = STALE_MS, } = options;
+    const marker = markerPath(stateDir, type);
+    const attemptStartMs = Date.now();
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            // `onCompromised` must RECORD, never throw. The library invokes it from
+            // an `fs.stat` callback with no caller on the stack, so its default
+            // (rethrow) becomes an uncaught exception — see {@link LockCompromisedError}.
+            let compromise = null;
+            const release = await lockfile.lock(marker, {
+                stale: staleMs,
+                retries: 0,
+                onCompromised: (err) => { compromise = err; },
+            });
+            sink.record({ kind: 'acquired', type, caller, waitMs: Date.now() - attemptStartMs, timestamp: Date.now() });
+            const acquiredAtMs = Date.now();
+            return async () => {
+                // proper-lockfile marks a compromised lock released and drops it from
+                // its registry BEFORE calling the handler (`setLockAsCompromised`), so
+                // calling `release()` now only yields `ERELEASED` — there is nothing
+                // left of ours to release.
+                if (compromise === null)
+                    await release();
+                // Recorded either way: the hold duration is real, and losing it would
+                // make the metrics under-report exactly the runs worth looking at.
+                sink.record({ kind: 'released', type, caller, holdMs: Date.now() - acquiredAtMs, timestamp: Date.now() });
+                if (compromise !== null)
+                    throw new LockCompromisedError(type, compromise);
+            };
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < maxRetries) {
+                await new Promise((res) => setTimeout(res, retryIntervalMs));
+            }
+        }
+    }
+    sink.record({ kind: 'failed', type, caller, waitMs: Date.now() - attemptStartMs, timestamp: Date.now() });
+    throw new Error(`Could not acquire ${type} lock after ${maxRetries + 1} attempt(s): ${String(lastError)}`);
+}
+// Lock directories currently held by this process. A single signal handler
+// removes ALL of them on shutdown — a per-`withLock` handler would race if
+// more than one lock were held at once, because the first handler's
+// `process.exit` pre-empts the others, leaking the second lock until its stale
+// timeout. One registry + one handler also avoids piling up signal listeners.
+const heldLockDirs = new Set();
+let signalHandlerInstalled = false;
+function installSignalHandlerOnce() {
+    if (signalHandlerInstalled)
+        return;
+    signalHandlerInstalled = true;
+    const onSignal = () => {
+        // release() is async and can't be awaited in a signal handler, so remove
+        // every held lock directory synchronously as a best-effort fallback.
+        for (const dir of heldLockDirs) {
+            try {
+                rmSync(dir, { recursive: true, force: true });
+            }
+            catch { /* already gone */ }
+        }
+        process.exit(1);
+    };
+    process.once('SIGTERM', onSignal);
+    process.once('SIGINT', onSignal);
+}
+/**
+ * Run `fn` while holding the given lock.
+ *
+ * The lock's directory is tracked in a process-wide registry that a single
+ * SIGTERM/SIGINT handler cleans up on shutdown, so an interrupted process does
+ * not leave `<type>.lock` behind for every lock it held.
+ *
+ * @throws {LockCompromisedError} if the lock was taken away while `fn` ran.
+ *   `fn` still completed — see that error's doc for what is and is not
+ *   guaranteed. If `fn` itself threw, that error is thrown instead.
+ */
+export async function withLock(stateDir, type, options, fn) {
+    const release = await acquireLock(stateDir, type, options);
+    const lockDir = markerPath(stateDir, type) + '.lock';
+    heldLockDirs.add(lockDir);
+    installSignalHandlerOnce();
+    let outcome;
+    try {
+        outcome = { ok: true, value: await fn() };
+    }
+    catch (error) {
+        outcome = { ok: false, error };
+    }
+    heldLockDirs.delete(lockDir);
+    try {
+        await release();
+    }
+    catch (releaseError) {
+        if (!outcome.ok)
+            throw outcome.error;
+        throw releaseError;
+    }
+    if (!outcome.ok)
+        throw outcome.error;
+    return outcome.value;
+}
+//# sourceMappingURL=lock.js.map

package/dist/store/lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../src/store/lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,QAAQ,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,yBAAyB,EAAwB,MAAM,kBAAkB,CAAC;AAQnF,MAAM,QAAQ,GAAG,MAAM,CAAC;AAExB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,6DAA6D;IACpD,MAAM,CAAU;IAEzB,YAAY,IAAc,EAAE,MAAe;QACzC,KAAK,CACH,OAAO,IAAI,8EAA8E;YACzF,kFAAkF,MAAM,CAAC,MAAM,CAAC,EAAE,CACnG,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CACF;AAED,wFAAwF;AACxF,SAAS,UAAU,CAAC,QAAgB,EAAE,IAAc;IAClD,OAAO,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;AAC9B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,SAAS,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACzC,KAAK,MAAM,IAAI,IAAI,CAAC,WAAW,CAAU,EAAE,CAAC;QAC1C,aAAa,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;IAC/D,CAAC;AACH,CAAC;AA6BD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,QAAgB,EAChB,IAAc,EACd,UAA0B,EAAE;IAE5B,MAAM,EACJ,UAAU,GAAG,CAAC,EACd,eAAe,GAAG,KAAK,EACvB,MAAM,GAAG,SAAS,EAClB,IAAI,GAAG,yBAAyB,CAAC,QAAQ,CAAC,EAC1C,OAAO,GAAG,QAAQ,GACnB,GAAG,OAAO,CAAC;IACZ,MAAM,MAAM,GAAG,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC1C,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAElC,IAAI,SAAkB,CAAC;IACvB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;QACvD,IAAI,CAAC;YACH,wEAAwE;YACxE,oEAAoE;YACpE,8EAA8E;YAC9E,IAAI,UAAU,GAAY,IAAI,CAAC;YAC/B,MAAM,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE;gBAC1C,KAAK,EAAE,OAAO;gBACd,OAAO,EAAE,CAAC;gBACV,aAAa,EAAE,CAAC,GAAY,EAAE,EAAE,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC;aACvD,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;YAE5G,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YAChC,OAAO,KAAK,IAAI,EAAE;gBAChB,sEAAsE;gBACtE,uEAAuE;gBACvE,qEAAqE;gBACrE,2BAA2B;gBAC3B,IAAI,UAAU,KAAK,IAAI;oBAAE,MAAM,OAAO,EAAE,CAAC;gBACzC,sEAAsE;gBACtE,mEAAmE;gBACnE,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBAC1G,IAAI,UAAU,KAAK,IAAI;oBAAE,MAAM,IAAI,oBAAoB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YAC5E,CAAC,CAAC;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,SAAS,GAAG,GAAG,CAAC;YAChB,IAAI,OAAO,GAAG,UAAU,EAAE,CAAC;gBACzB,MAAM,IAAI,OAAO,CAAO,CAAC,GAAG,EAAE,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC,CAAC;YACrE,CAAC;QACH,CAAC;IACH,CAAC;IAED,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC1G,MAAM,IAAI,KAAK,CACb,qBAAqB,IAAI,eAAe,UAAU,GAAG,CAAC,gBAAgB,MAAM,CAAC,SAAS,CAAC,EAAE,CAC1F,CAAC;AACJ,CAAC;AAED,2EAA2E;AAC3E,2EAA2E;AAC3E,oEAAoE;AACpE,+EAA+E;AAC/E,8EAA8E;AAC9E,MAAM,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;AACvC,IAAI,sBAAsB,GAAG,KAAK,CAAC;AAEnC,SAAS,wBAAwB;IAC/B,IAAI,sBAAsB;QAAE,OAAO;IACnC,sBAAsB,GAAG,IAAI,CAAC;IAC9B,MAAM,QAAQ,GAAG,GAAU,EAAE;QAC3B,yEAAyE;QACzE,qEAAqE;QACrE,KAAK,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAC/B,IAAI,CAAC;gBAAC,MAAM,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YAAC,CAAC;YAAC,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC;QACrF,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC,CAAC;IACF,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAClC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;AACnC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,QAAgB,EAChB,IAAc,EACd,OAAuB,EACvB,EAAoB;IAEpB,MAAM,OAAO,GAAG,MAAM,WAAW,CAAC,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAE3D,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC;IACrD,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC1B,wBAAwB,EAAE,CAAC;IAM3B,IAAI,OAAgB,CAAC;IACrB,IAAI,CAAC;QACH,OAAO,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC;IAC5C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;IACjC,CAAC;IAED,YAAY,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC7B,IAAI,CAAC;QACH,MAAM,OAAO,EAAE,CAAC;IAClB,CAAC;IAAC,OAAO,YAAY,EAAE,CAAC;QACtB,IAAI,CAAC,OAAO,CAAC,EAAE;YAAE,MAAM,OAAO,CAAC,KAAK,CAAC;QACrC,MAAM,YAAY,CAAC;IACrB,CAAC;IAED,IAAI,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,OAAO,CAAC,KAAK,CAAC;IACrC,OAAO,OAAO,CAAC,KAAK,CAAC;AACvB,CAAC"}

package/dist/store/lockMetrics.d.ts

@@ -0,0 +1,52 @@
+import type { LockType } from './lock.js';
+/**
+ * A single lock lifecycle event.
+ *
+ * `acquired` and `failed` are recorded synchronously with the outcome of an
+ * acquisition attempt (including retry backoff) — `waitMs` covers the full
+ * attempt, from first try to acquisition or final failure. `released` is
+ * recorded when the caller's release function completes and carries the
+ * hold duration, i.e. wall-clock time between acquisition and release.
+ */
+export type LockEvent = {
+    readonly kind: 'acquired';
+    readonly type: LockType;
+    readonly caller: string;
+    readonly waitMs: number;
+    readonly timestamp: number;
+} | {
+    readonly kind: 'released';
+    readonly type: LockType;
+    readonly caller: string;
+    readonly holdMs: number;
+    readonly timestamp: number;
+} | {
+    readonly kind: 'failed';
+    readonly type: LockType;
+    readonly caller: string;
+    readonly waitMs: number;
+    readonly timestamp: number;
+};
+/**
+ * Sink for lock lifecycle events.
+ *
+ * A role interface (§4.3) so tests can inject an in-memory fake instead of
+ * touching the filesystem (§4.4) — the only production implementation is
+ * {@link createFileLockMetricsSink}.
+ */
+export interface LockMetricsSink {
+    /** Must never throw — a metrics failure must never break lock acquisition/release. */
+    record(event: LockEvent): void;
+}
+export declare const LOCK_METRICS_FILENAME = "lock-metrics.jsonl";
+/**
+ * Default sink: appends one JSON line per event to `<stateDir>/lock-metrics.jsonl`.
+ *
+ * Synchronous and best-effort: lock acquire/release happens rarely relative
+ * to read-tool traffic (near-zero overhead on the hot path), and a write
+ * failure (e.g. read-only state dir) is swallowed rather than surfaced,
+ * matching the fire-and-forget discipline `telemetry/metrics.ts` already
+ * uses for tool-call metrics.
+ */
+export declare function createFileLockMetricsSink(stateDir: string): LockMetricsSink;
+//# sourceMappingURL=lockMetrics.d.ts.map

package/dist/store/lockMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockMetrics.d.ts","sourceRoot":"","sources":["../../src/store/lockMetrics.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AA0B1C;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GACjB;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEN;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,sFAAsF;IACtF,MAAM,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CAChC;AAKD,eAAO,MAAM,qBAAqB,uBAAuB,CAAC;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAW3E"}

package/dist/store/lockMetrics.js

@@ -0,0 +1,29 @@
+import { appendFileSync } from 'node:fs';
+import { join } from 'node:path';
+// Exported so telemetry/lockMetricsSummary.ts (D6, `mast metrics --locks`)
+// reads the same sink file this module writes, without duplicating the
+// literal filename.
+export const LOCK_METRICS_FILENAME = 'lock-metrics.jsonl';
+/**
+ * Default sink: appends one JSON line per event to `<stateDir>/lock-metrics.jsonl`.
+ *
+ * Synchronous and best-effort: lock acquire/release happens rarely relative
+ * to read-tool traffic (near-zero overhead on the hot path), and a write
+ * failure (e.g. read-only state dir) is swallowed rather than surfaced,
+ * matching the fire-and-forget discipline `telemetry/metrics.ts` already
+ * uses for tool-call metrics.
+ */
+export function createFileLockMetricsSink(stateDir) {
+    const path = join(stateDir, LOCK_METRICS_FILENAME);
+    return {
+        record(event) {
+            try {
+                appendFileSync(path, JSON.stringify(event) + '\n');
+            }
+            catch {
+                // Best-effort — see module WHY-comment.
+            }
+        },
+    };
+}
+//# sourceMappingURL=lockMetrics.js.map

package/dist/store/lockMetrics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockMetrics.js","sourceRoot":"","sources":["../../src/store/lockMetrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAuEjC,2EAA2E;AAC3E,uEAAuE;AACvE,oBAAoB;AACpB,MAAM,CAAC,MAAM,qBAAqB,GAAG,oBAAoB,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,UAAU,yBAAyB,CAAC,QAAgB;IACxD,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;IACnD,OAAO;QACL,MAAM,CAAC,KAAgB;YACrB,IAAI,CAAC;gBACH,cAAc,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;YACrD,CAAC;YAAC,MAAM,CAAC;gBACP,wCAAwC;YAC1C,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/store/sqliteChunkStore.d.ts

@@ -0,0 +1,44 @@
+import type { Db } from '../graph/db.js';
+import type { Chunk } from '../ast/types.js';
+export interface ChunkRecord {
+    chunk_id: string;
+    file_path: string;
+    start_line: number;
+    end_line: number;
+    content: string;
+    chunk_type: string;
+    symbol_name: string | null;
+    parent_symbol: string | null;
+    is_exported: boolean;
+    language: string;
+    file_mtime: number;
+}
+export interface ChunkStore {
+    /** Replace all chunks for `filePath` atomically. Returns rows removed. */
+    replaceChunksForFile(filePath: string, chunks: readonly Chunk[]): Promise<number>;
+    /** Delete all chunks for the given files. Returns total rows removed. */
+    deleteChunksForFiles(filePaths: readonly string[]): Promise<number>;
+    getChunksByFilePath(filePath: string): Promise<ChunkRecord[]>;
+    /** Unrecognised ids are silently skipped. */
+    getChunksByIds(ids: readonly string[]): Promise<ChunkRecord[]>;
+    getAllChunks(): Promise<ChunkRecord[]>;
+    chunkCount(): Promise<number>;
+}
+export declare class SqliteChunkStore implements ChunkStore {
+    private readonly db;
+    constructor(db: Db);
+    /**
+     * Used directly by `populateFile`'s default (no-override) path via a plain
+     * function reference, not this class — see `graph/populate.ts`'s
+     * `replaceChunksInline`. This method exists so `SqliteChunkStore` itself is
+     * a complete, independently-usable `ChunkStore` (tests construct it
+     * directly, and it is a valid `chunkStoreOverride`/`ChunkWriter` source).
+     */
+    replaceChunksForFile(filePath: string, chunks: readonly Chunk[]): Promise<number>;
+    deleteChunksForFiles(filePaths: readonly string[]): Promise<number>;
+    getChunksByFilePath(filePath: string): Promise<ChunkRecord[]>;
+    getChunksByIds(ids: readonly string[]): Promise<ChunkRecord[]>;
+    getAllChunks(): Promise<ChunkRecord[]>;
+    chunkCount(): Promise<number>;
+}
+//# sourceMappingURL=sqliteChunkStore.d.ts.map

package/dist/store/sqliteChunkStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqliteChunkStore.d.ts","sourceRoot":"","sources":["../../src/store/sqliteChunkStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AA6B7C,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAOD,MAAM,WAAW,UAAU;IACzB,0EAA0E;IAC1E,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAClF,yEAAyE;IACzE,oBAAoB,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACpE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAC9D,6CAA6C;IAC7C,cAAc,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAC/D,YAAY,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACvC,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/B;AAED,qBAAa,gBAAiB,YAAW,UAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,EAAE;IAEnC;;;;;;OAMG;IACG,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IA2BjF,oBAAoB,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAiBnE,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAS7D,cAAc,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IAmB9D,YAAY,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAKtC,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;CAOpC"}

package/dist/store/sqliteChunkStore.js

@@ -0,0 +1,135 @@
+import { chunkRowsForSqlite } from '../graph/sqliteBatch.js';
+export class SqliteChunkStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Used directly by `populateFile`'s default (no-override) path via a plain
+     * function reference, not this class — see `graph/populate.ts`'s
+     * `replaceChunksInline`. This method exists so `SqliteChunkStore` itself is
+     * a complete, independently-usable `ChunkStore` (tests construct it
+     * directly, and it is a valid `chunkStoreOverride`/`ChunkWriter` source).
+     */
+    async replaceChunksForFile(filePath, chunks) {
+        return this.db.transaction().execute(async (trx) => {
+            const row = await trx
+                .selectFrom('chunks')
+                .select((eb) => eb.fn.count('chunk_id').as('count'))
+                .where('file_path', '=', filePath)
+                .executeTakeFirst();
+            const removed = row?.count ?? 0;
+            await trx.deleteFrom('chunks').where('file_path', '=', filePath).execute();
+            if (chunks.length > 0) {
+                // Batched to stay under SQLite's 32,766 bound-parameter ceiling
+                // (Stage 4.5 S1, IMPLEMENTATION_PLAN.md) — an 11-column row caps a
+                // single unbatched INSERT at ~2,978 rows; a whale file's chunks
+                // otherwise throw `SqliteError: too many SQL variables` and roll
+                // back this whole transaction. Batching the STATEMENT, not the
+                // transaction, keeps every batch inside the same `trx`, so the
+                // file's chunks still land atomically (all-or-nothing) with each
+                // other — same as before, just as multiple INSERTs instead of one.
+                for (const batch of chunkRowsForSqlite(chunks.map(chunkToRow))) {
+                    await trx.insertInto('chunks').values(batch).execute();
+                }
+            }
+            return removed;
+        });
+    }
+    async deleteChunksForFiles(filePaths) {
+        if (filePaths.length === 0)
+            return 0;
+        return this.db.transaction().execute(async (trx) => {
+            let removed = 0;
+            for (const fp of filePaths) {
+                const row = await trx
+                    .selectFrom('chunks')
+                    .select((eb) => eb.fn.count('chunk_id').as('count'))
+                    .where('file_path', '=', fp)
+                    .executeTakeFirst();
+                removed += row?.count ?? 0;
+                await trx.deleteFrom('chunks').where('file_path', '=', fp).execute();
+            }
+            return removed;
+        });
+    }
+    async getChunksByFilePath(filePath) {
+        const rows = await this.db
+            .selectFrom('chunks')
+            .selectAll()
+            .where('file_path', '=', filePath)
+            .execute();
+        return rows.map(rowToChunkRecord);
+    }
+    async getChunksByIds(ids) {
+        if (ids.length === 0)
+            return [];
+        // Deliberately unbatched, and the bound is re-derived here rather than
+        // recalled: the largest id set any call site passes is 200 — `fused.ts`'s
+        // `candidateLimit = limit * 4` with `limit` capped at 50 by
+        // `mcp/tools/search.ts`'s schema — and `potential-matches.ts` passes at
+        // most its own limit of 50. That is well under SQLite's bound-parameter
+        // ceiling (`SQLITE_MAX_VARIABLES` = 32,766, `graph/sqliteBatch.ts`), so no
+        // batching is needed. This comment read "50" until 2026-08-20, which was
+        // the pre-`candidateLimit` figure; the conclusion was unaffected, but the
+        // number is what a future reader would check the ceiling against.
+        const rows = await this.db
+            .selectFrom('chunks')
+            .selectAll()
+            .where('chunk_id', 'in', ids)
+            .execute();
+        return rows.map(rowToChunkRecord);
+    }
+    async getAllChunks() {
+        const rows = await this.db.selectFrom('chunks').selectAll().execute();
+        return rows.map(rowToChunkRecord);
+    }
+    async chunkCount() {
+        const row = await this.db
+            .selectFrom('chunks')
+            .select((eb) => eb.fn.count('chunk_id').as('count'))
+            .executeTakeFirst();
+        return row?.count ?? 0;
+    }
+}
+// ---------------------------------------------------------------------------
+// Row <-> domain conversions
+// ---------------------------------------------------------------------------
+function chunkToRow(c) {
+    return {
+        chunk_id: c.chunk_id,
+        file_path: c.file_path,
+        start_line: c.start_line,
+        end_line: c.end_line,
+        content: c.content,
+        chunk_type: c.chunk_type,
+        symbol_name: c.symbol_name,
+        parent_symbol: c.parent_symbol,
+        is_exported: c.is_exported ? 1 : 0,
+        language: c.language,
+        file_mtime: c.file_mtime,
+    };
+}
+/**
+ * Explicit `0|1` -> `boolean` conversion at the store boundary. SQLite stores
+ * booleans as INTEGER (`BoolCol` convention, graph/db.ts) — every read here
+ * converts back to `boolean` explicitly so `SearchResult.is_exported`
+ * (search/hybrid.ts) and every MCP tool response never silently ships a
+ * number where a client expects `true`/`false`.
+ */
+function rowToChunkRecord(r) {
+    return {
+        chunk_id: r.chunk_id,
+        file_path: r.file_path,
+        start_line: r.start_line,
+        end_line: r.end_line,
+        content: r.content,
+        chunk_type: r.chunk_type,
+        symbol_name: r.symbol_name,
+        parent_symbol: r.parent_symbol,
+        is_exported: r.is_exported === 1,
+        language: r.language,
+        file_mtime: r.file_mtime,
+    };
+}
+//# sourceMappingURL=sqliteChunkStore.js.map

package/dist/store/sqliteChunkStore.js.map

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

package/dist/telemetry/lockMetricsSummary.d.ts

@@ -0,0 +1,42 @@
+/** Per-caller lock timing summary. */
+export interface LockCallerSummary {
+    readonly caller: string;
+    /** Number of completed acquire-then-release cycles observed for this caller. */
+    readonly count: number;
+    readonly hold_p50_ms: number;
+    readonly hold_p95_ms: number;
+    readonly hold_max_ms: number;
+    readonly wait_p50_ms: number;
+    readonly wait_p95_ms: number;
+    readonly wait_max_ms: number;
+    /** Acquisition attempts that exhausted retries without ever acquiring the lock. */
+    readonly failed_count: number;
+}
+export interface LockMetricsSummary {
+    readonly callers: readonly LockCallerSummary[];
+    /** Lines that failed JSON.parse or did not match the LockEvent schema — skipped, not thrown. */
+    readonly malformed_line_count: number;
+}
+/**
+ * Summarize raw `lock-metrics.jsonl` content into per-caller count/p50/p95/max
+ * for both hold duration (`released` events) and wait/acquire duration
+ * (`acquired` events), plus a failed-acquisition count (`failed` events).
+ *
+ * Pure — takes the file's text directly rather than a path, so it is
+ * unit-testable against fixture strings without touching the filesystem.
+ * Malformed lines (bad JSON, or JSON that doesn't match a known `LockEvent`
+ * shape) are skipped and counted rather than thrown, matching
+ * store/lockMetrics.ts's own best-effort discipline for this data.
+ */
+export declare function summarizeLockMetricsJsonl(jsonlContent: string): LockMetricsSummary;
+/**
+ * Read and summarize `<stateDir>/lock-metrics.jsonl`.
+ *
+ * Returns `null` when the file is missing or empty — the "no lock metrics
+ * recorded" case `mast metrics --locks` reports distinctly from a
+ * zero-caller summary, so callers can tell "never ran a coarse write" apart
+ * from "ran, but every event was malformed" (the latter still returns a
+ * summary object, with `malformed_line_count > 0` and `callers: []`).
+ */
+export declare function readLockMetricsSummary(stateDir: string): LockMetricsSummary | null;
+//# sourceMappingURL=lockMetricsSummary.d.ts.map

package/dist/telemetry/lockMetricsSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lockMetricsSummary.d.ts","sourceRoot":"","sources":["../../src/telemetry/lockMetricsSummary.ts"],"names":[],"mappings":"AAgDA,sCAAsC;AACtC,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC/C,gGAAgG;IAChG,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,kBAAkB,CAqElF;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAQlF"}