@meetless/mla 0.1.4

package/dist/lib/session-scope.js

@@ -0,0 +1,195 @@
+"use strict";
+// Resolve a session value into (a) the concrete sid to scope to and (b) the set of
+// note keys that session produced IN A GIVEN WORKSPACE, read from the active-memory
+// store the Zone-2 auto-index loop writes (see internal-auto-index.ts). Shared by
+// the kb review listing (session default) and any other session-scoped surface.
+//
+// The join key is the note BASENAME. Verified live 2026-06-07 against control:
+// candidate artifactIds are `note:<basename>` while the store records canonicalPath
+// as `notes/<basename>`. The route DTO documents notePath as a bare basename. So
+// the one normalization that makes the store join the candidate graph is
+// basename(canonicalPath).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCOPE_MAX_RECORDS = exports.SCOPE_TTL_HOURS = exports.SessionScopeError = void 0;
+exports.noteKey = noteKey;
+exports.noteArtifactId = noteArtifactId;
+exports.activeMemoryStorePath = activeMemoryStorePath;
+exports.resolveScopeSession = resolveScopeSession;
+exports.sessionNoteKeys = sessionNoteKeys;
+exports.candidateInSession = candidateInSession;
+exports.loadSessionScope = loadSessionScope;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("./config");
+const active_memory_1 = require("./active-memory");
+function noteKey(canonicalPath) {
+    // Normalize Windows separators defensively before taking the basename; the
+    // store is written on macOS/Linux today, so this is free correctness, not a
+    // supported-platform path.
+    return path.posix.basename(canonicalPath.replace(/\\/g, "/"));
+}
+function noteArtifactId(canonicalPath) {
+    return `note:${noteKey(canonicalPath)}`;
+}
+class SessionScopeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "SessionScopeError";
+        // Restore the prototype chain so `instanceof` survives ts-jest's ES target.
+        Object.setPrototypeOf(this, SessionScopeError.prototype);
+    }
+}
+exports.SessionScopeError = SessionScopeError;
+function activeMemoryStorePath() {
+    return path.join(config_1.HOME, "logs", "kb-knowledge.jsonl");
+}
+// Wider window than the auto-index loop (48h/100): a human reviewing "this
+// session" may run the command well after the work landed, and the store is small.
+exports.SCOPE_TTL_HOURS = 168; // 7 days
+exports.SCOPE_MAX_RECORDS = 1000;
+function resolveScopeSession(value, deps = {}) {
+    const v = value.trim();
+    if (v === "") {
+        throw new SessionScopeError("--session requires a value (a sid, or 'current' / 'latest')");
+    }
+    if (v !== "current" && v !== "latest") {
+        return { sessionId: v, source: "explicit" };
+    }
+    if (v === "current") {
+        const env = deps.env ?? process.env;
+        const sid = (env.CLAUDE_CODE_SESSION_ID || "").trim();
+        if (!sid) {
+            // NEVER fall back to "latest" silently; that would bind to a different
+            // session than the one the operator is in.
+            throw new SessionScopeError("--session current needs $CLAUDE_CODE_SESSION_ID, which is not set. " +
+                "Run inside a Claude Code session, pass an explicit sid, or use --session latest.");
+        }
+        return { sessionId: sid, source: "current-env" };
+    }
+    // v === "latest": explicit, loud opt-in to cross-session selection.
+    const storePath = deps.storePath ?? activeMemoryStorePath();
+    const sid = latestProducedDocSession(storePath, deps.workspaceId ?? null);
+    if (!sid) {
+        throw new SessionScopeError(`--session latest found no session that produced docs` +
+            `${deps.workspaceId ? ` in workspace ${deps.workspaceId}` : ""}. Pass an explicit sid.`);
+    }
+    return { sessionId: sid, source: "latest-store" };
+}
+// Latest session that PRODUCED a doc (the queue is scoped by produced docs, so a
+// session whose newest event was a tagged_reference is not a useful "latest").
+// Workspace-scoped so a foreign repo's session never wins.
+function latestProducedDocSession(storePath, workspaceId) {
+    let raw;
+    try {
+        raw = fs.readFileSync(storePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let best = null;
+    for (const line of raw.split("\n")) {
+        const s = line.trim();
+        if (!s)
+            continue;
+        let r;
+        try {
+            r = JSON.parse(s);
+        }
+        catch {
+            continue;
+        }
+        if (r.event !== "active_memory_record" || r.kind !== "produced_doc" || !r.sessionId)
+            continue;
+        if (workspaceId && r.workspaceId !== workspaceId)
+            continue;
+        const parsed = Date.parse(r.createdAt ?? r.ts ?? "");
+        // A record with no usable date cannot meaningfully be "latest"; skip it rather
+        // than letting a corrupt timestamp win by defaulting to epoch 0.
+        if (!Number.isFinite(parsed))
+            continue;
+        if (!best || parsed >= best.t)
+            best = { sid: r.sessionId, t: parsed };
+    }
+    return best?.sid ?? null;
+}
+// Reduce the active-memory store to the produced-doc note keys for one session in
+// one workspace. reduceActiveMemory returns [] on a missing file and filters to
+// event === "active_memory_record" + sessionId, so we only add the workspace +
+// kind filters here.
+function sessionNoteKeys(sessionId, deps) {
+    const storePath = deps.storePath ?? activeMemoryStorePath();
+    const records = (0, active_memory_1.reduceActiveMemory)(storePath, {
+        sessionId,
+        ttlHours: exports.SCOPE_TTL_HOURS,
+        maxRecords: exports.SCOPE_MAX_RECORDS,
+        nowMs: deps.nowMs,
+    });
+    const keys = new Set();
+    for (const r of records) {
+        if (r.kind !== "produced_doc")
+            continue;
+        if (r.workspaceId !== deps.workspaceId)
+            continue;
+        keys.add(noteKey(r.canonicalPath));
+    }
+    return { sessionId, keys };
+}
+function stripNotePrefix(artifactId) {
+    if (!artifactId)
+        return null;
+    return artifactId.startsWith("note:") ? artifactId.slice("note:".length) : null;
+}
+// A candidate belongs to the session if EITHER endpoint is a note the session
+// produced (the detected edge can put the new doc on the source or target side).
+function candidateInSession(c, keys) {
+    const s = stripNotePrefix(c.sourceArtifactId);
+    const t = stripNotePrefix(c.targetArtifactId);
+    return (s !== null && keys.has(s)) || (t !== null && keys.has(t));
+}
+// Convenience used by the command entrypoints: resolve the value, then load keys.
+function loadSessionScope(value, deps) {
+    const resolved = resolveScopeSession(value, {
+        env: deps.env,
+        storePath: deps.storePath,
+        workspaceId: deps.workspaceId,
+    });
+    const scope = sessionNoteKeys(resolved.sessionId, {
+        workspaceId: deps.workspaceId,
+        storePath: deps.storePath,
+        nowMs: deps.nowMs,
+    });
+    return { sessionId: resolved.sessionId, source: resolved.source, keys: scope.keys };
+}

package/dist/lib/spool.js

@@ -0,0 +1,355 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listActiveSessions = listActiveSessions;
+exports.queueDepth = queueDepth;
+exports.reapQueue = reapQueue;
+exports.planQueuePrune = planQueuePrune;
+exports.executeQueuePrune = executeQueuePrune;
+exports.runFlushScript = runFlushScript;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("./config");
+// Spool helpers used by `mla flush` to scan and drain pending queue files.
+// The actual flush mechanic lives in ~/.meetless/hooks/flush.sh; we call it
+// for each pending session so we share the same locking + transformation logic.
+function listActiveSessions() {
+    if (!fs.existsSync(config_1.QUEUE_DIR))
+        return [];
+    const out = new Set();
+    for (const f of fs.readdirSync(config_1.QUEUE_DIR)) {
+        if (f.endsWith(".jsonl")) {
+            out.add(f.replace(/\.jsonl$/, ""));
+        }
+        else if (f.includes(".jsonl.draining.")) {
+            out.add(f.split(".jsonl.")[0]);
+        }
+    }
+    return Array.from(out);
+}
+// queueDepth must account for both live spool files AND orphan
+// `.jsonl.draining.*` snapshots. The doctor surfaces oldestAgeSec as the
+// signal that something is stuck; an interrupted flush leaves the live file
+// gone and only a draining-suffixed remnant behind. If we measured age from
+// .jsonl files alone, a queue with N orphan drains stranded for hours would
+// show "oldest age n/a" and the operator would call doctor GREEN. Treat any
+// readable file in the queue dir (live or draining) as evidence of pending
+// work for the purposes of the oldest-age metric. `events` and `orphans`
+// stay split so the operator can still see which side is heavier.
+function queueDepth(queueDir = config_1.QUEUE_DIR) {
+    if (!fs.existsSync(queueDir))
+        return { sessions: 0, events: 0, orphans: 0, oldestAgeSec: null };
+    let events = 0;
+    let orphans = 0;
+    let oldestMs = Number.POSITIVE_INFINITY;
+    const sessions = new Set();
+    for (const f of fs.readdirSync(queueDir)) {
+        const full = path.join(queueDir, f);
+        if (f.endsWith(".jsonl")) {
+            sessions.add(f.replace(/\.jsonl$/, ""));
+            try {
+                const raw = fs.readFileSync(full, "utf8");
+                events += raw.split("\n").filter((l) => l.trim().length > 0).length;
+                const st = fs.statSync(full);
+                if (st.mtimeMs < oldestMs)
+                    oldestMs = st.mtimeMs;
+            }
+            catch { }
+        }
+        else if (f.includes(".jsonl.draining.")) {
+            orphans += 1;
+            sessions.add(f.split(".jsonl.")[0]);
+            try {
+                const raw = fs.readFileSync(full, "utf8");
+                events += raw.split("\n").filter((l) => l.trim().length > 0).length;
+                const st = fs.statSync(full);
+                if (st.mtimeMs < oldestMs)
+                    oldestMs = st.mtimeMs;
+            }
+            catch { }
+        }
+    }
+    return {
+        sessions: sessions.size,
+        events,
+        orphans,
+        oldestAgeSec: oldestMs === Number.POSITIVE_INFINITY ? null : Math.round((Date.now() - oldestMs) / 1000),
+    };
+}
+// Suffixes flush.sh / common.sh create per session, MOST-SPECIFIC FIRST.
+// classifyQueueFile returns on the first endsWith match, so the compound
+// `.hb.lock` / `.narration-cursor.lock` MUST precede the bare `.lock`, else
+// `<sid>.hb.lock` would classify under a phantom `<sid>.hb` session. reapQueue
+// ONLY removes files whose suffix is in this set, so a stray non-Meetless file
+// (or a `.workspaceId.bak.*` backup) is never touched. `.jsonl.draining.*` is
+// handled separately (variable `.<pid>` tail). `.off` lives in session-gate/,
+// not the queue dir, so it is intentionally absent here.
+const SIDECAR_SUFFIXES = [
+    ".hb.lock",
+    ".narration-cursor.lock",
+    ".narration-cursor",
+    ".hb",
+    ".repoPath",
+    ".gitBaseline",
+    ".workspaceId",
+    ".turn",
+    ".lock",
+];
+const DEFAULT_QUEUE_GC_MAX_AGE_SEC = 86_400; // 24h idle before a session is litter
+// Map a queue-dir filename to its (sessionId, kind) or null if it is not a
+// recognized Meetless artifact. Draining snapshots come first because they also
+// end in a numeric `.draining.<pid>` tail that the plain-suffix match would miss.
+function classifyQueueFile(name) {
+    const drainIdx = name.indexOf(".jsonl.draining.");
+    if (drainIdx > 0) {
+        return { sessionId: name.slice(0, drainIdx), isSpool: false, isDraining: true };
+    }
+    if (name.endsWith(".jsonl")) {
+        return { sessionId: name.slice(0, -".jsonl".length), isSpool: true, isDraining: false };
+    }
+    for (const sfx of SIDECAR_SUFFIXES) {
+        if (name.endsWith(sfx)) {
+            return { sessionId: name.slice(0, -sfx.length), isSpool: false, isDraining: false };
+        }
+    }
+    return null;
+}
+// reapQueue: age-gated GC of dead-session litter (RC2). A session is reaped only
+// when it has NO undelivered work (no non-empty `.jsonl`, no `.jsonl.draining.*`)
+// AND its NEWEST file is older than maxAgeSec. Newest-mtime is the liveness
+// heartbeat: an active session's `.jsonl`/`.turn` is rewritten every turn, so the
+// age gate cannot reap a session that is merely between turns. Unlinking a `.lock`
+// that another process holds is safe on POSIX (the lock is on the open inode; the
+// holder keeps it), and the 24h gate makes a concurrent live flush impossible
+// anyway. Pure function of the filesystem + injected `now` so it is deterministic
+// under test.
+function reapQueue(opts = {}) {
+    const queueDir = opts.queueDir ?? config_1.QUEUE_DIR;
+    const now = opts.now ?? Date.now();
+    const dryRun = opts.dryRun ?? false;
+    const maxAgeSec = opts.maxAgeSec ??
+        (process.env.MEETLESS_QUEUE_GC_MAX_AGE_SEC
+            ? Number(process.env.MEETLESS_QUEUE_GC_MAX_AGE_SEC)
+            : DEFAULT_QUEUE_GC_MAX_AGE_SEC);
+    const result = { reaped: [], removedFiles: 0, skippedPending: 0, skippedFresh: 0 };
+    if (!fs.existsSync(queueDir))
+        return result;
+    const groups = new Map();
+    for (const name of fs.readdirSync(queueDir)) {
+        const c = classifyQueueFile(name);
+        if (!c)
+            continue; // unrecognized -> never touch
+        const full = path.join(queueDir, name);
+        let g = groups.get(c.sessionId);
+        if (!g) {
+            g = { files: [], hasNonEmptySpool: false, hasDraining: false, newestMtimeMs: 0 };
+            groups.set(c.sessionId, g);
+        }
+        g.files.push(full);
+        let mtimeMs = 0;
+        let sizeNonEmpty = false;
+        try {
+            const st = fs.statSync(full);
+            mtimeMs = st.mtimeMs;
+            sizeNonEmpty = st.size > 0;
+        }
+        catch {
+            continue;
+        }
+        if (mtimeMs > g.newestMtimeMs)
+            g.newestMtimeMs = mtimeMs;
+        if (c.isSpool && sizeNonEmpty)
+            g.hasNonEmptySpool = true;
+        if (c.isDraining)
+            g.hasDraining = true;
+    }
+    for (const [sessionId, g] of groups) {
+        if (g.hasNonEmptySpool || g.hasDraining) {
+            result.skippedPending += 1;
+            continue;
+        }
+        const ageSec = (now - g.newestMtimeMs) / 1000;
+        if (ageSec < maxAgeSec) {
+            result.skippedFresh += 1;
+            continue;
+        }
+        let removed = 0;
+        for (const f of g.files) {
+            if (dryRun) {
+                // Count what WOULD be removed without touching disk (doctor's read-only
+                // debt probe). statSync already succeeded above for files we counted, so
+                // treat every grouped file as removable here.
+                removed += 1;
+                continue;
+            }
+            try {
+                fs.rmSync(f, { force: true });
+                removed += 1;
+            }
+            catch { }
+        }
+        if (removed > 0) {
+            result.reaped.push(sessionId);
+            result.removedFiles += removed;
+        }
+    }
+    return result;
+}
+// planQueuePrune: the EXPLICIT reclaimer (powers `mla queue prune`). Unlike
+// reapQueue it INCLUDES sessions with a non-empty `.jsonl` -- the stranded tails
+// reapQueue refuses by its data-loss-safety rule. Safe only because prune is
+// (a) manual, (b) age-gated (a session no hook has touched in maxAgeSec is dead),
+// and (c) flushed best-effort before deletion (executeQueuePrune). Pure function
+// of the filesystem + injected `now`.
+function planQueuePrune(opts = {}) {
+    const queueDir = opts.queueDir ?? config_1.QUEUE_DIR;
+    const now = opts.now ?? Date.now();
+    const maxAgeSec = opts.maxAgeSec ?? DEFAULT_QUEUE_GC_MAX_AGE_SEC;
+    const plan = {
+        candidates: [],
+        skippedFresh: 0,
+        totalFiles: 0,
+        totalUnflushedEvents: 0,
+        totalBytes: 0,
+        oldestAgeSec: null,
+    };
+    if (!fs.existsSync(queueDir))
+        return plan;
+    const groups = new Map();
+    for (const name of fs.readdirSync(queueDir)) {
+        const c = classifyQueueFile(name);
+        if (!c)
+            continue;
+        if (opts.sessionId && c.sessionId !== opts.sessionId)
+            continue;
+        const full = path.join(queueDir, name);
+        let g = groups.get(c.sessionId);
+        if (!g) {
+            g = { files: [], unflushedEvents: 0, bytes: 0, newestMtimeMs: 0 };
+            groups.set(c.sessionId, g);
+        }
+        g.files.push(full);
+        try {
+            const st = fs.statSync(full);
+            if (st.mtimeMs > g.newestMtimeMs)
+                g.newestMtimeMs = st.mtimeMs;
+            g.bytes += st.size;
+            if ((c.isSpool || c.isDraining) && st.size > 0) {
+                const raw = fs.readFileSync(full, "utf8");
+                g.unflushedEvents += raw.split("\n").filter((l) => l.trim().length > 0).length;
+            }
+        }
+        catch {
+            // unreadable -> still listed for deletion, just not counted
+        }
+    }
+    let oldest = null;
+    for (const [sessionId, g] of groups) {
+        const ageSec = (now - g.newestMtimeMs) / 1000;
+        if (ageSec < maxAgeSec) {
+            plan.skippedFresh += 1;
+            continue;
+        }
+        plan.candidates.push({
+            sessionId,
+            files: g.files,
+            unflushedEvents: g.unflushedEvents,
+            bytes: g.bytes,
+            newestMtimeMs: g.newestMtimeMs,
+            ageSec: Math.round(ageSec),
+        });
+        plan.totalFiles += g.files.length;
+        plan.totalUnflushedEvents += g.unflushedEvents;
+        plan.totalBytes += g.bytes;
+        if (oldest === null || ageSec > oldest)
+            oldest = ageSec;
+    }
+    plan.candidates.sort((a, b) => b.ageSec - a.ageSec);
+    plan.oldestAgeSec = oldest === null ? null : Math.round(oldest);
+    return plan;
+}
+// executeQueuePrune: best-effort flush each candidate (so deliverable events are
+// recovered, not discarded), then delete its remaining files. Flush is via the
+// real flush.sh (shared locking + transform), failures ignored -- a 3-day-dead
+// session whose AgentRun is gone simply will not deliver, and we prune it anyway.
+function executeQueuePrune(plan, opts = {}) {
+    const hookDir = opts.hookDir ?? config_1.HOOKS_DIR;
+    const doFlush = opts.flush ?? true;
+    const result = {
+        prunedSessions: [],
+        removedFiles: 0,
+        discardedEvents: 0,
+        flushedSessions: 0,
+        recoveredFiles: 0,
+    };
+    for (const c of plan.candidates) {
+        if (doFlush && c.unflushedEvents > 0 && fs.existsSync(path.join(hookDir, "flush.sh"))) {
+            const r = runFlushScript(c.sessionId, hookDir);
+            if (r.ok)
+                result.flushedSessions += 1;
+        }
+        let removed = 0;
+        let discarded = 0;
+        for (const f of c.files) {
+            try {
+                const st = fs.statSync(f); // throws if a flush already removed it
+                if ((f.endsWith(".jsonl") || f.includes(".jsonl.draining.")) && st.size > 0) {
+                    const raw = fs.readFileSync(f, "utf8");
+                    discarded += raw.split("\n").filter((l) => l.trim().length > 0).length;
+                }
+                fs.rmSync(f, { force: true });
+                removed += 1;
+            }
+            catch {
+                result.recoveredFiles += 1; // gone already (flush self-cleaned it)
+            }
+        }
+        if (removed > 0) {
+            result.prunedSessions.push(c.sessionId);
+            result.removedFiles += removed;
+            result.discardedEvents += discarded;
+        }
+    }
+    return result;
+}
+function runFlushScript(sessionId, hookDir) {
+    const flush = path.join(hookDir, "flush.sh");
+    if (!fs.existsSync(flush)) {
+        return { ok: false, stderr: `flush.sh not found at ${flush}` };
+    }
+    const r = (0, child_process_1.spawnSync)("bash", [flush, sessionId], { encoding: "utf8" });
+    return { ok: r.status === 0, stderr: r.stderr || "" };
+}

package/dist/lib/staleness.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMcpStaleCheck = makeMcpStaleCheck;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// build-info.json lives at the dist ROOT; this module compiles to dist/lib/, so
+// its sibling is one level up. Mirrors observability.ts's path convention, but
+// deliberately does NOT reuse loadBuildInfo(): that one caches process-lifetime
+// and synthesizes a fresh builtAt when the file is missing, both of which would
+// defeat a LIVE staleness probe (a cached spawn value can never differ; a
+// synthetic builtAt would false-positive on a real dev build).
+const DEFAULT_BUILD_INFO_PATH = path.join(__dirname, "..", "build-info.json");
+function defaultReadBuildIdentity() {
+    try {
+        const raw = fs.readFileSync(DEFAULT_BUILD_INFO_PATH, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.builtAt !== "string" || typeof parsed.sha !== "string") {
+            return null;
+        }
+        return { sha: parsed.sha, builtAt: parsed.builtAt };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build the per-call staleness probe for a long-lived `mla mcp` server. Snapshots
+ * the build identity at spawn, then on each call re-reads it and returns a one-
+ * line warning when a newer build has landed on disk, else null. Never throws,
+ * always fails open: if there was no identity at spawn (dev build), or either
+ * read is unavailable, it stays silent.
+ */
+function makeMcpStaleCheck(deps = {}) {
+    const read = deps.readBuildIdentity ?? defaultReadBuildIdentity;
+    let spawn;
+    try {
+        spawn = read();
+    }
+    catch {
+        spawn = null;
+    }
+    return () => {
+        // No spawn baseline (dev build) means we cannot tell "rebuilt" from "first
+        // ever stamp", so we never nag.
+        if (!spawn)
+            return null;
+        let current;
+        try {
+            current = read();
+        }
+        catch {
+            return null;
+        }
+        if (!current)
+            return null;
+        if (current.builtAt === spawn.builtAt && current.sha === spawn.sha) {
+            return null;
+        }
+        return staleWarning(spawn, current);
+    };
+}
+function staleWarning(spawn, current) {
+    return (`Meetless MCP is serving an OLDER build (${spawn.sha} @ ${spawn.builtAt}); ` +
+        `a newer mla build (${current.sha} @ ${current.builtAt}) is now on disk. ` +
+        `Restart your editor so the MCP server reloads; until then every result, ` +
+        `including this one, comes from the older code.`);
+}