@mastra/code-sdk 1.8.4-alpha.6 → 1.9.0-alpha.10

package/dist/utils/discarding-scores-storage.js

@@ -0,0 +1,54 @@
+import { ScoresStorage } from "@mastra/core/storage";
+//#region src/utils/discarding-scores-storage.ts
+/**
+* A scores domain that accepts writes and keeps nothing.
+*
+* mastracode's `outcome` and `efficiency` scorers persist every result through
+* the scores domain (`validateAndSaveScore` → `getStore('scores')`), but nothing
+* in mastracode reads scores back. Writing them to libsql grew mastra.db without
+* bound, and an in-memory store would grow the heap for the life of the process
+* instead (each payload carries the system prompt, messages, input and output).
+* Disabling the domain is not an option: core throws
+* MASTRA_SCORES_STORAGE_NOT_AVAILABLE on every scorer run when it is missing.
+*/
+var DiscardingScoresStorage = class extends ScoresStorage {
+	async getScoreById() {
+		return null;
+	}
+	async saveScore(score) {
+		const now = /* @__PURE__ */ new Date();
+		return { score: {
+			...score,
+			id: score.id ?? crypto.randomUUID(),
+			createdAt: now,
+			updatedAt: now
+		} };
+	}
+	async listScoresByScorerId({ pagination }) {
+		return empty(pagination);
+	}
+	async listScoresByRunId({ pagination }) {
+		return empty(pagination);
+	}
+	async listScoresByEntityId({ pagination }) {
+		return empty(pagination);
+	}
+	async listScoresBySpan({ pagination }) {
+		return empty(pagination);
+	}
+};
+function empty(pagination) {
+	return {
+		pagination: {
+			total: 0,
+			page: pagination.page,
+			perPage: pagination.perPage,
+			hasMore: false
+		},
+		scores: []
+	};
+}
+//#endregion
+export { DiscardingScoresStorage };
+
+//# sourceMappingURL=discarding-scores-storage.js.map

package/dist/utils/discarding-scores-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"discarding-scores-storage.js","names":[],"sources":["../../src/utils/discarding-scores-storage.ts"],"sourcesContent":["import type { ListScoresResponse, SaveScorePayload, ScoreRowData } from '@mastra/core/evals';\nimport { ScoresStorage } from '@mastra/core/storage';\nimport type { StoragePagination } from '@mastra/core/storage';\n\n/**\n * A scores domain that accepts writes and keeps nothing.\n *\n * mastracode's `outcome` and `efficiency` scorers persist every result through\n * the scores domain (`validateAndSaveScore` → `getStore('scores')`), but nothing\n * in mastracode reads scores back. Writing them to libsql grew mastra.db without\n * bound, and an in-memory store would grow the heap for the life of the process\n * instead (each payload carries the system prompt, messages, input and output).\n * Disabling the domain is not an option: core throws\n * MASTRA_SCORES_STORAGE_NOT_AVAILABLE on every scorer run when it is missing.\n */\nexport class DiscardingScoresStorage extends ScoresStorage {\n  async getScoreById(): Promise<ScoreRowData | null> {\n    return null;\n  }\n\n  async saveScore(score: SaveScorePayload): Promise<{ score: ScoreRowData }> {\n    const now = new Date();\n    return { score: { ...score, id: score.id ?? crypto.randomUUID(), createdAt: now, updatedAt: now } as ScoreRowData };\n  }\n\n  async listScoresByScorerId({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n\n  async listScoresByRunId({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n\n  async listScoresByEntityId({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n\n  async listScoresBySpan({ pagination }: { pagination: StoragePagination }): Promise<ListScoresResponse> {\n    return empty(pagination);\n  }\n}\n\nfunction empty(pagination: StoragePagination): ListScoresResponse {\n  return { pagination: { total: 0, page: pagination.page, perPage: pagination.perPage, hasMore: false }, scores: [] };\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,IAAa,0BAAb,cAA6C,cAAc;CACzD,MAAM,eAA6C;EACjD,OAAO;CACT;CAEA,MAAM,UAAU,OAA2D;EACzE,MAAM,sBAAM,IAAI,KAAK;EACrB,OAAO,EAAE,OAAO;GAAE,GAAG;GAAO,IAAI,MAAM,MAAM,OAAO,WAAW;GAAG,WAAW;GAAK,WAAW;EAAI,EAAkB;CACpH;CAEA,MAAM,qBAAqB,EAAE,cAA8E;EACzG,OAAO,MAAM,UAAU;CACzB;CAEA,MAAM,kBAAkB,EAAE,cAA8E;EACtG,OAAO,MAAM,UAAU;CACzB;CAEA,MAAM,qBAAqB,EAAE,cAA8E;EACzG,OAAO,MAAM,UAAU;CACzB;CAEA,MAAM,iBAAiB,EAAE,cAA8E;EACrG,OAAO,MAAM,UAAU;CACzB;AACF;AAEA,SAAS,MAAM,YAAmD;CAChE,OAAO;EAAE,YAAY;GAAE,OAAO;GAAG,MAAM,WAAW;GAAM,SAAS,WAAW;GAAS,SAAS;EAAM;EAAG,QAAQ,CAAC;CAAE;AACpH"}

package/dist/utils/maintenance-lock.d.ts

@@ -0,0 +1,42 @@
+export declare class MaintenanceLockError extends Error {
+    readonly ownerPids: number[];
+    constructor(message: string, ownerPids: number[]);
+}
+export declare function getMaintenanceLockPath(): string;
+/** Owner of a lock whose pid file is still being written (PID not known yet). */
+export declare const UNKNOWN_OWNER = -1;
+/**
+ * Creating a pid file (open, then write) is not atomic, so an empty or
+ * unparseable file may belong to a process that is mid-write. Only treat it as
+ * stale once it is older than this.
+ */
+export declare const MALFORMED_PID_FILE_GRACE_MS = 5000;
+/**
+ * PID holding the maintenance lock, `UNKNOWN_OWNER` while its pid file is still
+ * being written, or null. Stale locks are removed.
+ */
+export declare function getMaintenanceLockOwner(): number | null;
+/** PIDs of other live registered sessions. Stale registrations are removed. */
+export declare function getLiveSessionPids(): number[];
+/** Test-only: drop every registration held by this process and forget lock ownership. */
+export declare function resetSessionRegistrationsForTesting(): void;
+/** Register one running session in this process. Pair with exactly one unregisterSession(). */
+export declare function registerSession(): void;
+/** Release one registration made by registerSession(). */
+export declare function unregisterSession(): void;
+/**
+ * Register this session, then wait for any running maintenance to finish.
+ * Waits indefinitely by default: a vacuum on a multi-GB database can take
+ * minutes. With `timeoutMs`, throws after that long naming the holder.
+ */
+export declare function registerSessionAndWaitForMaintenance({ timeoutMs, pollMs, onWait, }?: {
+    timeoutMs?: number;
+    pollMs?: number;
+    onWait?: (ownerPid: number) => void;
+}): Promise<void>;
+/**
+ * Acquire the maintenance lock, then refuse if any mastracode session is live.
+ * Returns a release function.
+ */
+export declare function acquireMaintenanceLock(): () => void;
+//# sourceMappingURL=maintenance-lock.d.ts.map

package/dist/utils/maintenance-lock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maintenance-lock.d.ts","sourceRoot":"","sources":["../../src/utils/maintenance-lock.ts"],"names":[],"mappings":"AAiBA,qBAAa,oBAAqB,SAAQ,KAAK;aAG3B,SAAS,EAAE,MAAM,EAAE;gBADnC,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,MAAM,EAAE;CAKtC;AAcD,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED,iFAAiF;AACjF,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,OAAQ,CAAC;AAuCjD;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,GAAG,IAAI,CAgBvD;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,IAAI,MAAM,EAAE,CAmB7C;AAOD,yFAAyF;AACzF,wBAAgB,mCAAmC,IAAI,IAAI,CAG1D;AAYD,+FAA+F;AAC/F,wBAAgB,eAAe,IAAI,IAAI,CAStC;AAED,0DAA0D;AAC1D,wBAAgB,iBAAiB,IAAI,IAAI,CAIxC;AAED;;;;GAIG;AACH,wBAAsB,oCAAoC,CAAC,EACzD,SAAoB,EACpB,MAAY,EACZ,MAAM,GACP,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBnG;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,IAAI,CA0CnD"}

package/dist/utils/maintenance-lock.js

@@ -0,0 +1,199 @@
+import { getAppDataDir } from "./project.js";
+import path from "path";
+import fs from "fs";
+//#region src/utils/maintenance-lock.ts
+/**
+* Mutual exclusion between storage maintenance (`mastracode prune`) and running
+* mastracode sessions, using the same pid-file / stale-PID pattern as
+* thread-lock.ts.
+*
+* - Every process that opens storage registers a session pid file.
+* - `prune` holds `maintenance.lock` for its whole run.
+*
+* The checks are ordered so the race is closed both ways: `prune` acquires the
+* lock and THEN looks for live sessions; a starter registers and THEN looks for
+* the lock. Whichever acts second always sees the other.
+*/
+var MaintenanceLockError = class extends Error {
+	ownerPids;
+	constructor(message, ownerPids) {
+		super(message);
+		this.ownerPids = ownerPids;
+		this.name = "MaintenanceLockError";
+	}
+};
+function getLocksDir() {
+	const dir = path.join(getAppDataDir(), "locks");
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function getSessionsDir() {
+	const dir = path.join(getLocksDir(), "sessions");
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function getMaintenanceLockPath() {
+	return path.join(getLocksDir(), "maintenance.lock");
+}
+/** Owner of a lock whose pid file is still being written (PID not known yet). */
+const UNKNOWN_OWNER = -1;
+/**
+* Creating a pid file (open, then write) is not atomic, so an empty or
+* unparseable file may belong to a process that is mid-write. Only treat it as
+* stale once it is older than this.
+*/
+const MALFORMED_PID_FILE_GRACE_MS = 5e3;
+function isProcessAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+/** Whether a pid file with no readable PID is old enough to reap. Missing files count as reapable. */
+function isMalformedPidFileStale(file) {
+	try {
+		return Date.now() - fs.statSync(file).mtimeMs > MALFORMED_PID_FILE_GRACE_MS;
+	} catch {
+		return true;
+	}
+}
+function describeOwners(pids) {
+	const known = pids.filter((pid) => pid !== -1);
+	return known.length > 0 ? ` (PID ${known.join(", ")})` : "";
+}
+function readPid(file) {
+	try {
+		const pid = parseInt(fs.readFileSync(file, "utf-8").trim(), 10);
+		return isNaN(pid) ? null : pid;
+	} catch {
+		return null;
+	}
+}
+let lockHeld = false;
+/**
+* PID holding the maintenance lock, `UNKNOWN_OWNER` while its pid file is still
+* being written, or null. Stale locks are removed.
+*/
+function getMaintenanceLockOwner() {
+	const lockPath = getMaintenanceLockPath();
+	if (!fs.existsSync(lockPath)) return null;
+	const pid = readPid(lockPath);
+	if (pid === process.pid) {
+		if (lockHeld) return pid;
+	} else if (pid !== null && isProcessAlive(pid)) return pid;
+	if (pid === null && !isMalformedPidFileStale(lockPath)) return -1;
+	try {
+		fs.unlinkSync(lockPath);
+	} catch {}
+	return null;
+}
+/** PIDs of other live registered sessions. Stale registrations are removed. */
+function getLiveSessionPids() {
+	const dir = getSessionsDir();
+	const live = [];
+	for (const file of fs.readdirSync(dir)) {
+		if (!file.endsWith(".pid")) continue;
+		const filePath = path.join(dir, file);
+		const pid = readPid(filePath);
+		if (pid === process.pid) continue;
+		if (pid !== null && isProcessAlive(pid)) live.push(pid);
+		else if (pid === null && !isMalformedPidFileStale(filePath)) live.push(-1);
+		else try {
+			fs.unlinkSync(filePath);
+		} catch {}
+	}
+	return live;
+}
+let sessionRefs = 0;
+let exitHookInstalled = false;
+/** Test-only: drop every registration held by this process and forget lock ownership. */
+function resetSessionRegistrationsForTesting() {
+	while (sessionRefs > 0) unregisterSession();
+	lockHeld = false;
+}
+function getSessionPidPath() {
+	return path.join(getSessionsDir(), `${process.pid}.pid`);
+}
+function removeSessionPidFile() {
+	try {
+		fs.unlinkSync(getSessionPidPath());
+	} catch {}
+}
+/** Register one running session in this process. Pair with exactly one unregisterSession(). */
+function registerSession() {
+	if (sessionRefs === 0) fs.writeFileSync(getSessionPidPath(), String(process.pid), { mode: 420 });
+	sessionRefs++;
+	if (!exitHookInstalled) {
+		exitHookInstalled = true;
+		process.once("exit", removeSessionPidFile);
+	}
+}
+/** Release one registration made by registerSession(). */
+function unregisterSession() {
+	if (sessionRefs === 0) return;
+	sessionRefs--;
+	if (sessionRefs === 0) removeSessionPidFile();
+}
+/**
+* Register this session, then wait for any running maintenance to finish.
+* Waits indefinitely by default: a vacuum on a multi-GB database can take
+* minutes. With `timeoutMs`, throws after that long naming the holder.
+*/
+async function registerSessionAndWaitForMaintenance({ timeoutMs = Infinity, pollMs = 250, onWait } = {}) {
+	registerSession();
+	const deadline = Date.now() + timeoutMs;
+	let notified = false;
+	for (;;) {
+		const owner = getMaintenanceLockOwner();
+		if (owner === null) return;
+		if (!notified) {
+			notified = true;
+			onWait?.(owner);
+		}
+		if (Date.now() >= deadline) {
+			unregisterSession();
+			throw new MaintenanceLockError(`Storage maintenance (mastracode prune${describeOwners([owner])}) is still running after ${Math.round(timeoutMs / 1e3)}s. Wait for it to finish, or stop it, then start mastracode again.`, [owner]);
+		}
+		await new Promise((resolve) => setTimeout(resolve, pollMs));
+	}
+}
+/**
+* Acquire the maintenance lock, then refuse if any mastracode session is live.
+* Returns a release function.
+*/
+function acquireMaintenanceLock() {
+	const lockPath = getMaintenanceLockPath();
+	for (let attempt = 0;; attempt++) try {
+		fs.writeFileSync(lockPath, String(process.pid), {
+			flag: "wx",
+			mode: 420
+		});
+		lockHeld = true;
+		break;
+	} catch (error) {
+		if (error.code !== "EEXIST") throw error;
+		const owner = getMaintenanceLockOwner();
+		if (owner !== null || attempt > 0) throw new MaintenanceLockError(`Another mastracode prune is already running${owner === null ? "" : describeOwners([owner])}.`, owner === null ? [] : [owner]);
+	}
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		lockHeld = false;
+		if (readPid(lockPath) === process.pid) try {
+			fs.unlinkSync(lockPath);
+		} catch {}
+	};
+	const sessions = getLiveSessionPids();
+	if (sessions.length > 0) {
+		release();
+		throw new MaintenanceLockError(`mastracode is running${describeOwners(sessions)}. Exit every mastracode session before running prune.`, sessions);
+	}
+	return release;
+}
+//#endregion
+export { MALFORMED_PID_FILE_GRACE_MS, MaintenanceLockError, UNKNOWN_OWNER, acquireMaintenanceLock, getLiveSessionPids, getMaintenanceLockOwner, getMaintenanceLockPath, registerSession, registerSessionAndWaitForMaintenance, resetSessionRegistrationsForTesting, unregisterSession };
+
+//# sourceMappingURL=maintenance-lock.js.map

package/dist/utils/maintenance-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"maintenance-lock.js","names":[],"sources":["../../src/utils/maintenance-lock.ts"],"sourcesContent":["/**\n * Mutual exclusion between storage maintenance (`mastracode prune`) and running\n * mastracode sessions, using the same pid-file / stale-PID pattern as\n * thread-lock.ts.\n *\n * - Every process that opens storage registers a session pid file.\n * - `prune` holds `maintenance.lock` for its whole run.\n *\n * The checks are ordered so the race is closed both ways: `prune` acquires the\n * lock and THEN looks for live sessions; a starter registers and THEN looks for\n * the lock. Whichever acts second always sees the other.\n */\nimport fs from 'node:fs';\nimport path from 'node:path';\n\nimport { getAppDataDir } from './project.js';\n\nexport class MaintenanceLockError extends Error {\n  constructor(\n    message: string,\n    public readonly ownerPids: number[],\n  ) {\n    super(message);\n    this.name = 'MaintenanceLockError';\n  }\n}\n\nfunction getLocksDir(): string {\n  const dir = path.join(getAppDataDir(), 'locks');\n  fs.mkdirSync(dir, { recursive: true });\n  return dir;\n}\n\nfunction getSessionsDir(): string {\n  const dir = path.join(getLocksDir(), 'sessions');\n  fs.mkdirSync(dir, { recursive: true });\n  return dir;\n}\n\nexport function getMaintenanceLockPath(): string {\n  return path.join(getLocksDir(), 'maintenance.lock');\n}\n\n/** Owner of a lock whose pid file is still being written (PID not known yet). */\nexport const UNKNOWN_OWNER = -1;\n\n/**\n * Creating a pid file (open, then write) is not atomic, so an empty or\n * unparseable file may belong to a process that is mid-write. Only treat it as\n * stale once it is older than this.\n */\nexport const MALFORMED_PID_FILE_GRACE_MS = 5_000;\n\nfunction isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (error) {\n    // Only ESRCH proves the process is gone; EPERM etc. mean it exists.\n    return (error as NodeJS.ErrnoException).code !== 'ESRCH';\n  }\n}\n\n/** Whether a pid file with no readable PID is old enough to reap. Missing files count as reapable. */\nfunction isMalformedPidFileStale(file: string): boolean {\n  try {\n    return Date.now() - fs.statSync(file).mtimeMs > MALFORMED_PID_FILE_GRACE_MS;\n  } catch {\n    return true;\n  }\n}\n\nfunction describeOwners(pids: number[]): string {\n  const known = pids.filter(pid => pid !== UNKNOWN_OWNER);\n  return known.length > 0 ? ` (PID ${known.join(', ')})` : '';\n}\n\nfunction readPid(file: string): number | null {\n  try {\n    const pid = parseInt(fs.readFileSync(file, 'utf-8').trim(), 10);\n    return isNaN(pid) ? null : pid;\n  } catch {\n    return null;\n  }\n}\n\n// True while this process holds maintenance.lock, so an own-PID lock can be told\n// apart from a stale leftover whose PID we reused.\nlet lockHeld = false;\n\n/**\n * PID holding the maintenance lock, `UNKNOWN_OWNER` while its pid file is still\n * being written, or null. Stale locks are removed.\n */\nexport function getMaintenanceLockOwner(): number | null {\n  const lockPath = getMaintenanceLockPath();\n  if (!fs.existsSync(lockPath)) return null;\n  const pid = readPid(lockPath);\n  if (pid === process.pid) {\n    // We hold it (e.g. a concurrent prune in this process): a live owner.\n    if (lockHeld) return pid;\n    // Otherwise it is a leftover from a dead process whose PID we reused.\n  } else if (pid !== null && isProcessAlive(pid)) {\n    return pid;\n  }\n  if (pid === null && !isMalformedPidFileStale(lockPath)) return UNKNOWN_OWNER;\n  try {\n    fs.unlinkSync(lockPath);\n  } catch {}\n  return null;\n}\n\n/** PIDs of other live registered sessions. Stale registrations are removed. */\nexport function getLiveSessionPids(): number[] {\n  const dir = getSessionsDir();\n  const live: number[] = [];\n  for (const file of fs.readdirSync(dir)) {\n    if (!file.endsWith('.pid')) continue;\n    const filePath = path.join(dir, file);\n    const pid = readPid(filePath);\n    if (pid === process.pid) continue;\n    if (pid !== null && isProcessAlive(pid)) {\n      live.push(pid);\n    } else if (pid === null && !isMalformedPidFileStale(filePath)) {\n      live.push(UNKNOWN_OWNER);\n    } else {\n      try {\n        fs.unlinkSync(filePath);\n      } catch {}\n    }\n  }\n  return live;\n}\n\n// Refcounted: one process may start several sessions (e.g. repeated\n// createMastraCode() calls). The pid file exists while the count is > 0.\nlet sessionRefs = 0;\nlet exitHookInstalled = false;\n\n/** Test-only: drop every registration held by this process and forget lock ownership. */\nexport function resetSessionRegistrationsForTesting(): void {\n  while (sessionRefs > 0) unregisterSession();\n  lockHeld = false;\n}\n\nfunction getSessionPidPath(): string {\n  return path.join(getSessionsDir(), `${process.pid}.pid`);\n}\n\nfunction removeSessionPidFile(): void {\n  try {\n    fs.unlinkSync(getSessionPidPath());\n  } catch {}\n}\n\n/** Register one running session in this process. Pair with exactly one unregisterSession(). */\nexport function registerSession(): void {\n  if (sessionRefs === 0) {\n    fs.writeFileSync(getSessionPidPath(), String(process.pid), { mode: 0o644 });\n  }\n  sessionRefs++;\n  if (!exitHookInstalled) {\n    exitHookInstalled = true;\n    process.once('exit', removeSessionPidFile);\n  }\n}\n\n/** Release one registration made by registerSession(). */\nexport function unregisterSession(): void {\n  if (sessionRefs === 0) return;\n  sessionRefs--;\n  if (sessionRefs === 0) removeSessionPidFile();\n}\n\n/**\n * Register this session, then wait for any running maintenance to finish.\n * Waits indefinitely by default: a vacuum on a multi-GB database can take\n * minutes. With `timeoutMs`, throws after that long naming the holder.\n */\nexport async function registerSessionAndWaitForMaintenance({\n  timeoutMs = Infinity,\n  pollMs = 250,\n  onWait,\n}: { timeoutMs?: number; pollMs?: number; onWait?: (ownerPid: number) => void } = {}): Promise<void> {\n  registerSession();\n  const deadline = Date.now() + timeoutMs;\n  let notified = false;\n  for (;;) {\n    const owner = getMaintenanceLockOwner();\n    if (owner === null) return;\n    if (!notified) {\n      notified = true;\n      onWait?.(owner);\n    }\n    if (Date.now() >= deadline) {\n      unregisterSession();\n      throw new MaintenanceLockError(\n        `Storage maintenance (mastracode prune${describeOwners([owner])}) is still running after ${Math.round(timeoutMs / 1000)}s. ` +\n          `Wait for it to finish, or stop it, then start mastracode again.`,\n        [owner],\n      );\n    }\n    await new Promise(resolve => setTimeout(resolve, pollMs));\n  }\n}\n\n/**\n * Acquire the maintenance lock, then refuse if any mastracode session is live.\n * Returns a release function.\n */\nexport function acquireMaintenanceLock(): () => void {\n  const lockPath = getMaintenanceLockPath();\n  for (let attempt = 0; ; attempt++) {\n    try {\n      // 'wx' makes creation atomic, so two prunes cannot both win.\n      fs.writeFileSync(lockPath, String(process.pid), { flag: 'wx', mode: 0o644 });\n      lockHeld = true;\n      break;\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;\n      // getMaintenanceLockOwner() removes a stale lock, so the retry can win.\n      const owner = getMaintenanceLockOwner();\n      if (owner !== null || attempt > 0) {\n        throw new MaintenanceLockError(\n          `Another mastracode prune is already running${owner === null ? '' : describeOwners([owner])}.`,\n          owner === null ? [] : [owner],\n        );\n      }\n    }\n  }\n\n  let released = false;\n  const release = () => {\n    if (released) return;\n    released = true;\n    lockHeld = false;\n    if (readPid(lockPath) === process.pid) {\n      try {\n        fs.unlinkSync(lockPath);\n      } catch {}\n    }\n  };\n\n  const sessions = getLiveSessionPids();\n  if (sessions.length > 0) {\n    release();\n    throw new MaintenanceLockError(\n      `mastracode is running${describeOwners(sessions)}. Exit every mastracode session before running prune.`,\n      sessions,\n    );\n  }\n  return release;\n}\n"],"mappings":"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"}

package/dist/utils/project.js

@@ -1,9 +1,9 @@
 import { DEFAULT_CONFIG_DIR } from "../constants.js";
-import { createHash } from "crypto";
-import fs from "fs";
-import os from "os";
 import path from "path";
 import { execFile, execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import { createHash } from "crypto";
 //#region src/utils/project.ts
 /**
 * Project detection utilities

package/dist/utils/prune-cli.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `mastracode prune` — storage maintenance from a non-interactive shell.
+ *
+ * The in-TUI `/prune` command has to stop the UI, quiesce background writers
+ * (MCP, workers, intervals) and then exit the process, because retention
+ * deletes and VACUUM need the database to themselves. A standalone process
+ * already satisfies that contract — and, unlike `/prune`, it does not require a
+ * rendered prompt first, so maintenance stays reachable when the TUI cannot
+ * start. Without it a large mastra.db has no in-app remedy (issue #22056).
+ *
+ * Usage:
+ *   mastracode prune                 delete rows older than the retention policies
+ *   mastracode prune --vacuum        prune, then checkpoint WAL + VACUUM to return disk to the OS
+ *                                    (local libsql only; remote libsql and Postgres only prune rows)
+ *   mastracode prune --keep-memory   prune, but keep chat history (messages/threads)
+ */
+import type { StorageConfig } from './project.js';
+/**
+ * Run storage maintenance for the project in the current directory.
+ * Returns the process exit code (0 on success).
+ */
+export declare function runPruneCommand(args: string[]): Promise<number>;
+export declare function describeStorageTarget(config: StorageConfig): string;
+//# sourceMappingURL=prune-cli.d.ts.map

package/dist/utils/prune-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune-cli.d.ts","sourceRoot":"","sources":["../../src/utils/prune-cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAYH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAiBlD;;;GAGG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAuCrE;AA2ED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CASnE"}

package/dist/utils/prune-cli.js

@@ -0,0 +1,125 @@
+import { DEFAULT_CONFIG_DIR } from "../constants.js";
+import { detectProject, getStorageConfig } from "./project.js";
+import { loadSettings } from "../onboarding/settings.js";
+import { acquireMaintenanceLock } from "./maintenance-lock.js";
+import { DEFAULT_RETENTION, createStorageMaintenance, resolveLocalDbFiles, runStorageMaintenance } from "./storage-maintenance.js";
+import { createStorage, createVectorStore } from "./storage-factory.js";
+import path from "path";
+import { LibSQLVector } from "@mastra/libsql";
+//#region src/utils/prune-cli.ts
+/**
+* `mastracode prune` — storage maintenance from a non-interactive shell.
+*
+* The in-TUI `/prune` command has to stop the UI, quiesce background writers
+* (MCP, workers, intervals) and then exit the process, because retention
+* deletes and VACUUM need the database to themselves. A standalone process
+* already satisfies that contract — and, unlike `/prune`, it does not require a
+* rendered prompt first, so maintenance stays reachable when the TUI cannot
+* start. Without it a large mastra.db has no in-app remedy (issue #22056).
+*
+* Usage:
+*   mastracode prune                 delete rows older than the retention policies
+*   mastracode prune --vacuum        prune, then checkpoint WAL + VACUUM to return disk to the OS
+*                                    (local libsql only; remote libsql and Postgres only prune rows)
+*   mastracode prune --keep-memory   prune, but keep chat history (messages/threads)
+*/
+const USAGE = `Usage: mastracode prune [--vacuum] [--keep-memory]
+
+  --vacuum        After pruning, compact the local database files so freed
+                  pages are returned to the OS. Needs free disk for the copy.
+                  Local libsql only; remote libsql and Postgres only prune rows.
+  --keep-memory   Prune everything except chat history (messages/threads).
+`;
+/**
+* Run storage maintenance for the project in the current directory.
+* Returns the process exit code (0 on success).
+*/
+async function runPruneCommand(args) {
+	if (args.includes("--help") || args.includes("-h")) {
+		console.log(USAGE);
+		return 0;
+	}
+	const flags = new Set(args.map((a) => a.toLowerCase()));
+	const unknown = [...flags].filter((f) => f !== "--vacuum" && f !== "--keep-memory");
+	if (unknown.length > 0) {
+		console.error(`Unknown prune option: ${unknown.join(", ")}\n${USAGE}`);
+		return 1;
+	}
+	const vacuum = flags.has("--vacuum");
+	const keepMemory = flags.has("--keep-memory");
+	try {
+		process.loadEnvFile(path.join(process.cwd(), ".env"));
+	} catch {}
+	let releaseLock;
+	try {
+		releaseLock = acquireMaintenanceLock();
+	} catch (err) {
+		console.error(err instanceof Error ? err.message : String(err));
+		return 1;
+	}
+	try {
+		return await prune({
+			vacuum,
+			keepMemory
+		});
+	} finally {
+		releaseLock();
+	}
+}
+async function prune({ vacuum, keepMemory }) {
+	const settings = loadSettings();
+	const storageConfig = getStorageConfig(detectProject(process.cwd()).rootPath, settings.storage, DEFAULT_CONFIG_DIR);
+	console.log(`Storage target: ${describeStorageTarget(storageConfig)}`);
+	const { storage, backend, warning } = await createStorage(storageConfig);
+	if (warning) console.log(warning);
+	let vector;
+	try {
+		await storage.init();
+		const localDbFiles = resolveLocalDbFiles(storageConfig, backend);
+		if (localDbFiles.length > 0) console.log(`Database: ${localDbFiles.join(", ")}`);
+		if (vacuum && localDbFiles.length > 0) vector = await createVectorStore(storageConfig, backend);
+		const libsqlVector = vector instanceof LibSQLVector ? vector : void 0;
+		await runStorageMaintenance({
+			maintenance: createStorageMaintenance({
+				storage,
+				backend,
+				retention: DEFAULT_RETENTION,
+				localDbFiles,
+				...libsqlVector ? { closeVector: () => libsqlVector.close() } : {}
+			}),
+			vacuum,
+			keepMemory,
+			log: (line) => console.log(line)
+		});
+		console.log("Storage maintenance complete.");
+		return 0;
+	} catch (err) {
+		console.error(`Storage maintenance failed: ${err instanceof Error ? err.message : String(err)}`);
+		try {
+			await storage.close?.();
+			if (vector instanceof LibSQLVector) await vector.close();
+		} catch {}
+		return 1;
+	}
+}
+/** Credential-free URL: drops userinfo and the query string (e.g. ?authToken=). */
+function redactUrl(raw) {
+	try {
+		const url = new URL(raw);
+		url.username = "";
+		url.password = "";
+		url.search = "";
+		return url.toString();
+	} catch {
+		return "<unparseable URL>";
+	}
+}
+function describeStorageTarget(config) {
+	if (config.backend === "libsql") return config.url.startsWith("file:") ? `libsql file ${config.url.slice(5)}` : `libsql ${redactUrl(config.url)}`;
+	if (config.connectionString) return `pg ${redactUrl(config.connectionString)}`;
+	return `pg postgres://${`${config.host ?? "localhost"}${config.port ? `:${config.port}` : ""}`}/${config.database ?? ""}`;
+}
+//#endregion
+export { describeStorageTarget, runPruneCommand };
+
+//# sourceMappingURL=prune-cli.js.map

package/dist/utils/prune-cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune-cli.js","names":[],"sources":["../../src/utils/prune-cli.ts"],"sourcesContent":["/**\n * `mastracode prune` — storage maintenance from a non-interactive shell.\n *\n * The in-TUI `/prune` command has to stop the UI, quiesce background writers\n * (MCP, workers, intervals) and then exit the process, because retention\n * deletes and VACUUM need the database to themselves. A standalone process\n * already satisfies that contract — and, unlike `/prune`, it does not require a\n * rendered prompt first, so maintenance stays reachable when the TUI cannot\n * start. Without it a large mastra.db has no in-app remedy (issue #22056).\n *\n * Usage:\n *   mastracode prune                 delete rows older than the retention policies\n *   mastracode prune --vacuum        prune, then checkpoint WAL + VACUUM to return disk to the OS\n *                                    (local libsql only; remote libsql and Postgres only prune rows)\n *   mastracode prune --keep-memory   prune, but keep chat history (messages/threads)\n */\n\nimport path from 'node:path';\n\nimport type { MastraVector } from '@mastra/core/vector';\nimport { LibSQLVector } from '@mastra/libsql';\n\nimport { DEFAULT_CONFIG_DIR } from '../constants.js';\nimport { loadSettings } from '../onboarding/settings.js';\n\nimport { acquireMaintenanceLock } from './maintenance-lock.js';\nimport { detectProject, getStorageConfig } from './project.js';\nimport type { StorageConfig } from './project.js';\nimport { createStorage, createVectorStore } from './storage-factory.js';\nimport {\n  DEFAULT_RETENTION,\n  createStorageMaintenance,\n  resolveLocalDbFiles,\n  runStorageMaintenance,\n} from './storage-maintenance.js';\n\nconst USAGE = `Usage: mastracode prune [--vacuum] [--keep-memory]\n\n  --vacuum        After pruning, compact the local database files so freed\n                  pages are returned to the OS. Needs free disk for the copy.\n                  Local libsql only; remote libsql and Postgres only prune rows.\n  --keep-memory   Prune everything except chat history (messages/threads).\n`;\n\n/**\n * Run storage maintenance for the project in the current directory.\n * Returns the process exit code (0 on success).\n */\nexport async function runPruneCommand(args: string[]): Promise<number> {\n  if (args.includes('--help') || args.includes('-h')) {\n    console.log(USAGE);\n    return 0;\n  }\n\n  const flags = new Set(args.map(a => a.toLowerCase()));\n  const unknown = [...flags].filter(f => f !== '--vacuum' && f !== '--keep-memory');\n  if (unknown.length > 0) {\n    console.error(`Unknown prune option: ${unknown.join(', ')}\\n${USAGE}`);\n    return 1;\n  }\n  const vacuum = flags.has('--vacuum');\n  const keepMemory = flags.has('--keep-memory');\n\n  // Startup loads the project .env before registering its session and resolving\n  // storage (MASTRA_APP_DATA_DIR, MASTRA_DB_PATH, ...). Do the same before taking\n  // the lock, or prune locks/scans a different app data dir or opens another DB.\n  try {\n    process.loadEnvFile(path.join(process.cwd(), '.env'));\n  } catch {\n    // No .env file — keys may be in the shell environment\n  }\n\n  // Maintenance needs the database to itself: hold the lock for the whole run\n  // and refuse while any mastracode session is registered.\n  let releaseLock: () => void;\n  try {\n    releaseLock = acquireMaintenanceLock();\n  } catch (err) {\n    console.error(err instanceof Error ? err.message : String(err));\n    return 1;\n  }\n\n  try {\n    return await prune({ vacuum, keepMemory });\n  } finally {\n    releaseLock();\n  }\n}\n\nasync function prune({ vacuum, keepMemory }: { vacuum: boolean; keepMemory: boolean }): Promise<number> {\n  // Resolve storage exactly the way startup does, so prune targets the same\n  // database the TUI uses — honoring MASTRA_DB_PATH / MASTRA_STORAGE_BACKEND,\n  // global settings, and a project's own .mastracode/database.json.\n  const settings = loadSettings();\n  const project = detectProject(process.cwd());\n  const storageConfig = getStorageConfig(project.rootPath, settings.storage, DEFAULT_CONFIG_DIR);\n\n  // A project .env can point storage elsewhere (startup honors it too), so say\n  // exactly what is about to be pruned before anything is deleted.\n  console.log(`Storage target: ${describeStorageTarget(storageConfig)}`);\n\n  const { storage, backend, warning } = await createStorage(storageConfig);\n  if (warning) console.log(warning);\n\n  let vector: MastraVector | undefined;\n  try {\n    // The libsql factory does not init (the PG path already has); init is\n    // coalesced, so tables are guaranteed to exist before we delete from them.\n    await storage.init();\n\n    const localDbFiles = resolveLocalDbFiles(storageConfig, backend);\n    if (localDbFiles.length > 0) {\n      console.log(`Database: ${localDbFiles.join(', ')}`);\n    }\n\n    // Only the local-libsql compaction needs the vector connection (its file\n    // swap refuses while any connection is open). Opening it otherwise would\n    // create mastra-vectors.db as a side effect.\n    if (vacuum && localDbFiles.length > 0) {\n      vector = await createVectorStore(storageConfig, backend);\n    }\n    const libsqlVector = vector instanceof LibSQLVector ? vector : undefined;\n\n    const maintenance = createStorageMaintenance({\n      storage,\n      backend,\n      retention: DEFAULT_RETENTION,\n      localDbFiles,\n      ...(libsqlVector ? { closeVector: () => libsqlVector.close() } : {}),\n    });\n\n    await runStorageMaintenance({ maintenance, vacuum, keepMemory, log: line => console.log(line) });\n    console.log('Storage maintenance complete.');\n    return 0;\n  } catch (err) {\n    console.error(`Storage maintenance failed: ${err instanceof Error ? err.message : String(err)}`);\n    // runStorageMaintenance closes storage on its success path. If it threw\n    // first, release the connections here so a retry isn't blocked by our own\n    // open handles. Best effort — the original failure is what matters.\n    try {\n      await storage.close?.();\n      if (vector instanceof LibSQLVector) await vector.close();\n    } catch {\n      // ignore cleanup errors\n    }\n    return 1;\n  }\n}\n\n/** Credential-free URL: drops userinfo and the query string (e.g. ?authToken=). */\nfunction redactUrl(raw: string): string {\n  try {\n    const url = new URL(raw);\n    url.username = '';\n    url.password = '';\n    url.search = '';\n    return url.toString();\n  } catch {\n    return '<unparseable URL>';\n  }\n}\n\nexport function describeStorageTarget(config: StorageConfig): string {\n  if (config.backend === 'libsql') {\n    return config.url.startsWith('file:')\n      ? `libsql file ${config.url.slice('file:'.length)}`\n      : `libsql ${redactUrl(config.url)}`;\n  }\n  if (config.connectionString) return `pg ${redactUrl(config.connectionString)}`;\n  const host = `${config.host ?? 'localhost'}${config.port ? `:${config.port}` : ''}`;\n  return `pg postgres://${host}/${config.database ?? ''}`;\n}\n"],"mappings":"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"}

package/dist/utils/signals-pubsub.js

@@ -1,5 +1,5 @@
-import { createHash } from "crypto";
 import { join } from "path";
+import { createHash } from "crypto";
 import { mkdir } from "fs/promises";
 import { PubSub, UnixSocketPubSub } from "@mastra/core/events";
 //#region src/utils/signals-pubsub.ts

package/dist/utils/slash-command-loader.js

@@ -1,7 +1,7 @@
 import { DEFAULT_CONFIG_DIR } from "../constants.js";
 import { isPathWithinRoot } from "./path-security.js";
-import { promises } from "fs";
 import * as path$1 from "path";
+import { promises } from "fs";
 import { parse } from "yaml";
 //#region src/utils/slash-command-loader.ts
 /**

package/dist/utils/slash-command-processor.js

@@ -1,6 +1,6 @@
-import { promises } from "fs";
 import * as path$1 from "path";
 import { execSync } from "child_process";
+import { promises } from "fs";
 //#region src/utils/slash-command-processor.ts
 /**
 * Process a slash command by replacing variables and executing shell commands

package/dist/utils/storage-maintenance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"storage-maintenance.d.ts","sourceRoot":"","sources":["../../src/utils/storage-maintenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQ7G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAe/B,CAAC;AAEF,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,cAAc,GAAG,kBAAkB,CAAC;CAC/C;AAED,4FAA4F;AAC5F,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,mEAAmE;IACnE,SAAS,EAAE,eAAe,CAAC;IAC3B,qKAAqK;IACrK,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1D,wHAAwH;IACxH,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,2HAA2H;IAC3H,WAAW,CAAC,EAAE,CACZ,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,KACzE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CAC/B;AAeD,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3D;AAkDD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GAC3E,OAAO,CAAC,aAAa,EAAE,CAAC,CAuH1B;AAQD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,gBAAgB,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,EAAE,CAatG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,OAAO,EAAE,oBAAoB,CAAC;IAC9B,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,eAAe,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,8HAA8H;IAC9H,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC,GAAG,kBAAkB,CAiBrB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWjD;AAKD;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,WAAW,EAAE,kBAAkB,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B,GAAG,OAAO,CAAC,IAAI,CAAC,CAgGhB"}
+{"version":3,"file":"storage-maintenance.d.ts","sourceRoot":"","sources":["../../src/utils/storage-maintenance.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAOH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQ7G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGlD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAe/B,CAAC;AAEF,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,cAAc,GAAG,kBAAkB,CAAC;CAC/C;AAED,4FAA4F;AAC5F,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,mEAAmE;IACnE,SAAS,EAAE,eAAe,CAAC;IAC3B,qKAAqK;IACrK,KAAK,EAAE,CAAC,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAC1D,wHAAwH;IACxH,YAAY,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,2HAA2H;IAC3H,WAAW,CAAC,EAAE,CACZ,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,KACzE,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;CAC/B;AAeD,4FAA4F;AAC5F,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3D;AAkFD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GAC3E,OAAO,CAAC,aAAa,EAAE,CAAC,CA4H1B;AAQD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,EAAE,gBAAgB,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,EAAE,CAatG;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,OAAO,EAAE,oBAAoB,CAAC;IAC9B,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,eAAe,CAAC;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,8HAA8H;IAC9H,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC,GAAG,kBAAkB,CAiBrB;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWjD;AAKD;;;;;;;;;GASG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,WAAW,EAAE,kBAAkB,CAAC;IAChC,MAAM,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAC7B,GAAG,OAAO,CAAC,IAAI,CAAC,CAkGhB"}

package/dist/utils/storage-maintenance.js

@@ -1,6 +1,8 @@
 import { getDatabasePath, getVectorDatabasePath } from "./project.js";
-import { closeSync, existsSync, openSync, readSync, renameSync, rmSync, statSync, statfsSync } from "fs";
 import { dirname } from "path";
+import { closeSync, existsSync, openSync, readSync, renameSync, rmSync, statSync, statfsSync } from "fs";
+import { setFlagsFromString } from "v8";
+import { runInNewContext } from "vm";
 import Database from "libsql";
 //#region src/utils/storage-maintenance.ts
 /**
@@ -71,6 +73,33 @@ function journalModeFromHeader(file) {
 	}
 }
 /**
+* Collect our own closed-but-unfinalized libsql connections before probing.
+*
+* libsql-js does not finalize prepared statements on `close()` (they are only
+* released by GC; tursodatabase/libsql-js#228), so a connection we already
+* closed can still hold the WAL lock and make the reclaim probe fail.
+*
+* `gc` is only global under `--expose-gc`, so we set that V8 flag at runtime
+* and read `gc` from a fresh VM context. The flag is process-wide, but it only
+* makes `gc` available to contexts created afterward (the main context's
+* globals are untouched) and changes no GC behavior. A forced
+* collection only frees unreachable objects. This runs only on the explicit
+* vacuum path (`mastracode prune --vacuum` or `/prune vacuum`), and both exit
+* the process right after, so the flag never outlives maintenance in practice.
+*
+* Remove this once libsql-js#228 lands and `close()` finalizes statements.
+*/
+async function releaseClosedConnections() {
+	await new Promise((resolve) => setImmediate(resolve));
+	const gc = globalThis.gc ?? (() => {
+		setFlagsFromString("--expose-gc");
+		return runInNewContext("gc");
+	})();
+	gc();
+	await new Promise((resolve) => setTimeout(resolve, 50));
+	gc();
+}
+/**
 * Does this database carry a libsql vector index?
 *
 * Takes an already-open connection on purpose: the query needs a prepared
@@ -121,6 +150,7 @@ async function reclaimLibSQLDisk(dbFiles, onFileStart) {
 		const bytesBefore = fileSizeWithWal(file);
 		const tmp = `${file}.vacuum-tmp`;
 		rmSync(tmp, { force: true });
+		await releaseClosedConnections();
 		const probe = new Database(file);
 		try {
 			probe.exec("PRAGMA busy_timeout = 2000");
@@ -129,7 +159,7 @@ async function reclaimLibSQLDisk(dbFiles, onFileStart) {
 		} catch {} finally {
 			probe.close();
 		}
-		if (journalModeFromHeader(file) !== "delete") throw new Error(`${file} is in use by another process — is another Mastra Code session running? Close other sessions and run /prune vacuum again.`);
+		if (journalModeFromHeader(file) !== "delete") throw new Error(`${file} is in use by another process — is another Mastra Code session running? Close other sessions, then run /prune vacuum (or mastracode prune --vacuum) again.`);
 		const db = new Database(file);
 		try {
 			db.exec("PRAGMA busy_timeout = 2000");
@@ -165,7 +195,7 @@ async function reclaimLibSQLDisk(dbFiles, onFileStart) {
 		}
 		if (journalModeFromHeader(file) !== "delete") {
 			rmSync(tmp, { force: true });
-			throw new Error(`${file} was opened by another process during compaction — is another Mastra Code session running? Close other sessions and run /prune vacuum again.`);
+			throw new Error(`${file} was opened by another process during compaction — is another Mastra Code session running? Close other sessions, then run /prune vacuum (or mastracode prune --vacuum) again.`);
 		}
 		renameSync(file, `${file}.old`);
 		try {
@@ -290,7 +320,7 @@ async function runStorageMaintenance(opts) {
 	log(totalDeleted === 0 ? "Nothing to prune — no retention-eligible rows found." : `Prune complete: ${totalDeleted} rows deleted.`);
 	await maintenance.closeStorage?.();
 	if (!vacuum) {
-		if (maintenance.reclaimDisk) log("Deleted rows free pages inside the db file but not on disk. Run /prune vacuum to reclaim disk space.");
+		if (maintenance.reclaimDisk) log("Deleted rows free pages inside the db file but not on disk. Run /prune vacuum (or mastracode prune --vacuum) to reclaim disk space.");
 		return;
 	}
 	if (!maintenance.reclaimDisk) {