om-memory-system 5.7.0-next.218 → 5.9.0

package/dist/adapters/opencode/self-update.d.ts

@@ -0,0 +1,19 @@
+import { type HostSelfUpdateDeps } from "../../services/host-self-update.js";
+/** The background service checks npm at start and then this often, like the footer. */
+export declare const OPENCODE_SERVICE_CHECK_MS: number;
+/** Production inputs for OpenCode: npm, the OpenCode marker file and a detached `opencode plugin update`. */
+export declare function opencodeSelfUpdateDeps(options: {
+    modulePath: string;
+    currentVersion: string;
+    log: HostSelfUpdateDeps["log"];
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+}): HostSelfUpdateDeps;
+/**
+ * Run the update check now and then every `intervalMs`. A failed check never
+ * throws. The timer does not keep the process alive. Returns a stop function.
+ */
+export declare function startOpencodeServiceSelfUpdate(options: {
+    run: () => unknown;
+    intervalMs?: number;
+}): () => void;

package/dist/adapters/opencode/self-update.js

@@ -0,0 +1,42 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { hostSelfUpdateDeps, installedFromNpm, unpinnedCacheFolder, } from "../../services/host-self-update.js";
+// OpenCode's update inputs, shared by the TUI footer and the background
+// service. The service runs the check too, so OpenCode without a TUI (for
+// example OpenChamber or `opencode serve`) also updates. The marker file stops
+// the two from starting the same update twice.
+/** The background service checks npm at start and then this often, like the footer. */
+export const OPENCODE_SERVICE_CHECK_MS = 6 * 3_600_000;
+/** Production inputs for OpenCode: npm, the OpenCode marker file and a detached `opencode plugin update`. */
+export function opencodeSelfUpdateDeps(options) {
+    const { modulePath } = options;
+    return hostSelfUpdateDeps({
+        logLabel: "OpenCode plugin self-update",
+        currentVersion: options.currentVersion,
+        command: "opencode",
+        args: ["plugin", "update", "om-memory-system"],
+        markerPath: join(options.home ?? homedir(), ".omms", "opencode-plugin-update.json"),
+        modulePath,
+        installSource: () => !installedFromNpm(modulePath) ? "local" : unpinnedCacheFolder(modulePath) ? "npm" : "pinned",
+        log: options.log,
+        ...(options.env ? { env: options.env } : {}),
+    });
+}
+/**
+ * Run the update check now and then every `intervalMs`. A failed check never
+ * throws. The timer does not keep the process alive. Returns a stop function.
+ */
+export function startOpencodeServiceSelfUpdate(options) {
+    const check = () => {
+        try {
+            void Promise.resolve(options.run()).catch(() => { });
+        }
+        catch {
+            // The update is housekeeping. It never breaks the service.
+        }
+    };
+    check();
+    const timer = setInterval(check, options.intervalMs ?? OPENCODE_SERVICE_CHECK_MS);
+    timer.unref?.();
+    return () => clearInterval(timer);
+}

package/dist/adapters/opencode/tui-status.d.ts

@@ -1,7 +1,10 @@
+import { type HostSelfUpdateResult, type HostUpdateStatus } from "../../services/host-self-update.js";
 /** What the OpenCode footer shows: the web app's state and a newer release, if any. */
 export interface TuiStatusState {
     web: "warming" | "connected" | "offline";
     update: string | null;
+    /** "installed" once the background update has finished; otherwise "available". */
+    updateState?: "available" | "installed";
 }
 export declare function tuiStatusText(state: TuiStatusState): string;
 export interface TuiStatusDeps {
@@ -9,15 +12,22 @@ export interface TuiStatusDeps {
     healthUrl: string;
     fetch: typeof fetch;
     setText: (text: string) => void;
-    /** Shown once per start when a newer release is on npm. */
+    /** Shown once per update state and version. */
     notify: (message: string) => void;
     checkUpdates?: boolean;
     healthIntervalMs?: number;
     updateIntervalMs?: number;
+    /** Reads npm and starts the background update. Without it the check only reads npm. */
+    selfUpdate?: () => Promise<HostSelfUpdateResult>;
+    /** The state the update marker records for a version. */
+    readUpdateStatus?: (version: string) => HostUpdateStatus | null;
+    watchIntervalMs?: number;
+    watchLimitMs?: number;
 }
 /**
  * Keep the footer text current: the web app is polled, and npm is asked for a
- * newer release at start and then every few hours. Returns a stop function.
+ * newer release at start and then every few hours. A newer release installs in
+ * the background when the host allows it. Returns a stop function.
  */
 export declare function startTuiStatus(deps: TuiStatusDeps): () => void;
 /** Wire the status to this install: its version, the configured web app port, and global fetch. */

package/dist/adapters/opencode/tui-status.js

@@ -1,17 +1,27 @@
+import { fileURLToPath } from "node:url";
+import { hostUpdateStatus, startHostSelfUpdate, updateNotice, updateSuffix, watchHostUpdate, } from "../../services/host-self-update.js";
 import { ommsStatusLabel } from "../../services/status-glyphs.js";
+import { opencodeSelfUpdateDeps } from "./self-update.js";
 import { availableUpdate, latestNpmVersion } from "../../services/update-check.js";
+const UPDATE_COMMAND = "opencode plugin update om-memory-system";
+// The background service keeps the old copy loaded until it restarts too.
+const RESTART = "restart OpenCode and run opencode service restart";
 export function tuiStatusText(state) {
     const web = ommsStatusLabel(state.web === "offline" ? "web app off" : state.web);
-    return state.update ? `${web} · ${state.update} available` : web;
+    return state.update
+        ? `${web}${updateSuffix(state.update, state.updateState ?? "available")}`
+        : web;
 }
 /**
  * Keep the footer text current: the web app is polled, and npm is asked for a
- * newer release at start and then every few hours. Returns a stop function.
+ * newer release at start and then every few hours. A newer release installs in
+ * the background when the host allows it. Returns a stop function.
  */
 export function startTuiStatus(deps) {
     const state = { web: "warming", update: null };
     let stopped = false;
-    let notified = null;
+    let stopWatch;
+    const shown = new Set();
     const show = () => {
         if (!stopped)
             deps.setText(tuiStatusText(state));
@@ -26,13 +36,65 @@ export function startTuiStatus(deps) {
         }
         show();
     };
-    const checkUpdate = async () => {
-        const update = availableUpdate(deps.currentVersion, await latestNpmVersion(deps.fetch));
-        state.update = update;
+    /** One toast per update state and version. */
+    const toast = (update, notice) => {
+        const key = `${notice}:${update}`;
+        if (stopped || shown.has(key))
+            return;
+        shown.add(key);
+        deps.notify(updateNotice({
+            hostName: "OpenCode",
+            command: UPDATE_COMMAND,
+            restart: RESTART,
+            current: deps.currentVersion,
+            update,
+            state: notice,
+        }));
+    };
+    const settle = (update, outcome) => {
+        state.updateState = outcome === "installed" ? "installed" : "available";
         show();
-        if (update && notified !== update && !stopped) {
-            notified = update;
-            deps.notify(`om-memory-system ${update} is available (running ${deps.currentVersion}). Run: opencode plugin update om-memory-system, then restart OpenCode.`);
+        toast(update, outcome === "installed" ? "installed" : "available");
+    };
+    const selfUpdate = deps.selfUpdate ??
+        (async () => ({
+            code: "local",
+            update: availableUpdate(deps.currentVersion, await latestNpmVersion(deps.fetch)),
+        }));
+    const checkUpdate = async () => {
+        try {
+            // The restart installs the release; there is nothing more to ask npm.
+            if (state.updateState === "installed")
+                return;
+            const { code, update } = await selfUpdate();
+            state.update = update;
+            state.updateState = "available";
+            show();
+            if (!update || stopped)
+                return;
+            if (code !== "started" && code !== "recent")
+                return toast(update, "available");
+            const status = (deps.readUpdateStatus ?? (() => null))(update);
+            if (status === "installed" || status === "failed")
+                return settle(update, status);
+            toast(update, "installing");
+            stopWatch?.();
+            stopWatch = watchHostUpdate({
+                read: () => (deps.readUpdateStatus ?? (() => null))(update),
+                onSettled: (outcome) => {
+                    try {
+                        settle(update, outcome);
+                    }
+                    catch {
+                        // A failed toast must not break the timer.
+                    }
+                },
+                intervalMs: deps.watchIntervalMs,
+                maxMs: deps.watchLimitMs,
+            });
+        }
+        catch {
+            // A failed update check must not break the footer.
         }
     };
     show();
@@ -47,20 +109,31 @@ export function startTuiStatus(deps) {
         timer.unref?.();
     return () => {
         stopped = true;
+        stopWatch?.();
         for (const timer of timers)
             clearInterval(timer);
     };
 }
 /** Wire the status to this install: its version, the configured web app port, and global fetch. */
 export async function startInstalledTuiStatus(callbacks) {
-    const [{ CONFIG }, { packageVersion }] = await Promise.all([
+    const [{ CONFIG }, { packageVersion }, { log }] = await Promise.all([
         import("../../config.js"),
         import("../../services/package-version.js"),
+        import("../../services/logger.js"),
     ]);
     const host = CONFIG.webServerHost === "0.0.0.0" ? "127.0.0.1" : CONFIG.webServerHost;
+    const currentVersion = packageVersion();
+    const modulePath = fileURLToPath(import.meta.url);
+    const update = opencodeSelfUpdateDeps({
+        modulePath,
+        currentVersion,
+        log: (message, data) => log(message, data),
+    });
     return startTuiStatus({
         ...callbacks,
-        currentVersion: packageVersion(),
+        currentVersion,
+        selfUpdate: () => startHostSelfUpdate(update),
+        readUpdateStatus: (version) => hostUpdateStatus(update, version),
         healthUrl: `http://${host.includes(":") ? `[${host}]` : host}:${CONFIG.webServerPort}/api/health`,
         fetch: globalThis.fetch.bind(globalThis),
         checkUpdates: process.env.OMMS_DISABLE_UPDATE_CHECK !== "1",

package/dist/adapters/pi/extension.js

@@ -14,6 +14,7 @@ import { registerPiSkillsTool } from "./skills-tool.js";
 import { performPiProfileLearning } from "./profile.js";
 import { createPiRecallRows } from "./recall-rows.js";
 import { createPiSessionContext } from "./session-context.js";
+import { createPiSelfUpdate } from "./self-update.js";
 import { DEFAULT_RETRIEVAL_MAX_TOKENS, tokensToByteCeiling } from "../../core/context-budget.js";
 import { ommsStatusLabel } from "../../services/status-glyphs.js";
 const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("omms.plugin.warmedup");
@@ -82,21 +83,30 @@ export default function ommsPiExtension(pi) {
     let latestCtx = null;
     let backfillSessionId = null;
     let statusVersion = 0;
+    // The glyph on screen, so a new update suffix can redraw the label. Null once cleared.
+    let shownStatus = null;
+    const selfUpdate = createPiSelfUpdate();
     const recallRows = createPiRecallRows();
     const sessionContext = createPiSessionContext(recallRows);
+    // Every label carries the update suffix, so it stays when the glyph changes.
+    const drawStatus = (ctx, status) => {
+        shownStatus = status;
+        if (ctx.hasUI)
+            ctx.ui.setStatus(OMMS_STATUS_KEY, ommsStatusLabel(status) + selfUpdate.suffix());
+    };
     const startStatus = (ctx, status) => {
         const version = ++statusVersion;
-        if (ctx.hasUI)
-            ctx.ui.setStatus(OMMS_STATUS_KEY, ommsStatusLabel(status));
+        drawStatus(ctx, status);
         return version;
     };
     const finishStatus = (ctx, version, status) => {
         if (version !== statusVersion || !ctx.hasUI)
             return;
-        ctx.ui.setStatus(OMMS_STATUS_KEY, ommsStatusLabel(status));
+        drawStatus(ctx, status);
     };
     const clearStatus = (ctx) => {
         statusVersion++;
+        shownStatus = null;
         if (ctx.hasUI)
             ctx.ui.setStatus(OMMS_STATUS_KEY, undefined);
     };
@@ -108,6 +118,11 @@ export default function ommsPiExtension(pi) {
     };
     pi.on("session_start", async (event, ctx) => {
         const status = startStatus(ctx, "warming");
+        // The update check does not delay the session and cannot stop memory work.
+        void selfUpdate.start({ hasUI: ctx.hasUI, notify: (message, level) => ctx.ui.notify(message, level) }, () => {
+            if (shownStatus)
+                drawStatus(ctx, shownStatus);
+        });
         try {
             latestCtx = ctx;
             initConfigWithLegacyMigration(ctx.cwd);
@@ -309,6 +324,7 @@ export default function ommsPiExtension(pi) {
         }
     });
     pi.on("session_shutdown", async (_event, ctx) => {
+        selfUpdate.stop();
         clearStatus(ctx);
         recallRows.reset(ctx);
         sessionContext.reset();

package/dist/adapters/pi/self-update.d.ts

@@ -0,0 +1,25 @@
+import { watchHostUpdate, type HostSelfUpdateDeps } from "../../services/host-self-update.js";
+/** What the update needs from one Pi session. */
+export interface PiUpdateSession {
+    hasUI: boolean;
+    notify: (message: string, level: "info" | "warning") => void;
+}
+export interface PiSelfUpdate {
+    /** Check npm and start the update. Never rejects. The caller does not wait for it. */
+    start(session: PiUpdateSession, onSuffixChange: () => void): Promise<void>;
+    /** Footer text to add after the status glyph, or an empty string. */
+    suffix(): string;
+    /** Stop the marker poll and drop the session. Keeps the suffix for the next session. */
+    stop(): void;
+}
+export interface PiSelfUpdateOptions {
+    hostDeps?: () => HostSelfUpdateDeps;
+    watch?: typeof watchHostUpdate;
+    log?: (message: string, data: Record<string, unknown>, level?: "error") => void;
+}
+/** Production inputs for Pi: npm, the Pi marker file and a detached `pi update`. */
+export declare function piHostSelfUpdateDeps(options?: {
+    env?: NodeJS.ProcessEnv;
+    modulePath?: string;
+}): HostSelfUpdateDeps;
+export declare function createPiSelfUpdate(options?: PiSelfUpdateOptions): PiSelfUpdate;

package/dist/adapters/pi/self-update.js

@@ -0,0 +1,146 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { hostSelfUpdateDeps, hostUpdateStatus, installedFromNpm, startHostSelfUpdate, unpinnedPackageSource, updateNotice, updateSuffix, watchHostUpdate, } from "../../services/host-self-update.js";
+import { log } from "../../services/logger.js";
+import { packageVersion } from "../../services/package-version.js";
+// Pi does not update its packages by itself. At session start OMMS runs
+// `pi update npm:om-memory-system` in the background when npm has a newer
+// release, then tells the user to restart. The decision lives in
+// `src/services/host-self-update.ts`; this file adds the Pi wording, the
+// footer suffix and the install check.
+const PI_UPDATE_ARGS = ["update", "npm:om-memory-system"];
+const PI_UPDATE_COMMAND = `pi ${PI_UPDATE_ARGS.join(" ")}`;
+/** Pi's settings file lists the package source. `PI_CODING_AGENT_DIR` moves Pi's folder. */
+function readPiSettings(env) {
+    const dir = env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
+    try {
+        return readFileSync(join(dir, "settings.json"), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Production inputs for Pi: npm, the Pi marker file and a detached `pi update`. */
+export function piHostSelfUpdateDeps(options = {}) {
+    const env = options.env ?? process.env;
+    const modulePath = options.modulePath ?? fileURLToPath(import.meta.url);
+    const installSource = () => {
+        if (!installedFromNpm(modulePath))
+            return "local";
+        return unpinnedPackageSource(readPiSettings(env)) ? "npm" : "pinned";
+    };
+    return hostSelfUpdateDeps({
+        logLabel: "Pi plugin self-update",
+        currentVersion: packageVersion(),
+        command: "pi",
+        args: PI_UPDATE_ARGS,
+        markerPath: join(homedir(), ".omms", "pi-plugin-update.json"),
+        modulePath,
+        installSource,
+        log,
+        env,
+    });
+}
+export function createPiSelfUpdate(options = {}) {
+    const hostDeps = options.hostDeps ?? (() => piHostSelfUpdateDeps());
+    const watch = options.watch ?? watchHostUpdate;
+    const logError = options.log ?? log;
+    // One notification per state per version for the life of the Pi process.
+    const notified = new Set();
+    let suffix = "";
+    let stopWatch = null;
+    let generation = 0;
+    let current = null;
+    // Sessions that start while a check runs share it, so one release spawns one update.
+    let inFlight = null;
+    // Once installed, only a restart helps: a later session must not run the update again.
+    let installed = false;
+    const attempt = (action) => {
+        try {
+            action();
+        }
+        catch {
+            // A stale Pi context must not stop the update path.
+        }
+    };
+    const notifyOnce = (key, message, level) => {
+        if (!current || notified.has(key))
+            return;
+        notified.add(key);
+        const { session } = current;
+        attempt(() => session.notify(message, level));
+    };
+    const show = (deps, update, state) => {
+        if (state === "installed")
+            installed = true;
+        if (state !== "installing") {
+            const next = updateSuffix(update, state);
+            if (next !== suffix) {
+                suffix = next;
+                const change = current?.onSuffixChange;
+                if (change)
+                    attempt(change);
+            }
+        }
+        const text = updateNotice({
+            hostName: "Pi",
+            command: PI_UPDATE_COMMAND,
+            current: deps.currentVersion,
+            update,
+            state,
+        });
+        notifyOnce(`${state}:${update}`, text, state === "available" ? "warning" : "info");
+    };
+    return {
+        async start(session, onSuffixChange) {
+            const mine = ++generation;
+            stopWatch?.();
+            stopWatch = null;
+            current = session.hasUI ? { session, onSuffixChange } : null;
+            if (installed)
+                return;
+            try {
+                const deps = hostDeps();
+                inFlight ??= startHostSelfUpdate(deps).finally(() => {
+                    inFlight = null;
+                });
+                const { code, update } = await inFlight;
+                // No interface, no label or notice. A shutdown or newer session replaces this one.
+                if (!update || !session.hasUI || mine !== generation)
+                    return;
+                if (code !== "started" && code !== "recent") {
+                    show(deps, update, "available");
+                    return;
+                }
+                const read = () => hostUpdateStatus(deps, update);
+                const status = read();
+                if (status === "installed")
+                    show(deps, update, "installed");
+                else if (status === "failed")
+                    show(deps, update, "available");
+                else {
+                    show(deps, update, "installing");
+                    stopWatch = watch({
+                        read,
+                        onSettled: (outcome) => {
+                            if (mine === generation)
+                                show(deps, update, outcome === "installed" ? "installed" : "available");
+                        },
+                    });
+                }
+            }
+            catch (error) {
+                logError("Pi plugin self-update failed", { code: error instanceof Error ? error.name : "unknown" }, "error");
+            }
+        },
+        suffix: () => suffix,
+        stop() {
+            generation++;
+            stopWatch?.();
+            stopWatch = null;
+            current = null;
+        },
+    };
+}

package/dist/cli/space-command.js

@@ -107,6 +107,18 @@ function parseSpaceArgs(argv) {
     parsed.directory = parsed.values.get("directory");
     return parsed;
 }
+/** One line per space for the list action: the display name first, the id after it. */
+function spaceListLines(result) {
+    const spaces = (result.spaces ?? []);
+    return spaces.map((space) => {
+        let line = `${space.name} (${space.id})`;
+        if (space.active)
+            line += " [active]";
+        if (space.archived)
+            line += " [archived]";
+        return line;
+    });
+}
 /** Run `om-memory-system space ...` and return the process exit code. */
 export async function runSpaceCommand(argv, io = {}) {
     const stdout = io.stdout ?? ((text) => console.log(text));
@@ -184,6 +196,14 @@ export async function runSpaceCommand(argv, io = {}) {
     catch (error) {
         result = { success: false, error: error instanceof Error ? error.message : String(error) };
     }
-    stdout(JSON.stringify(result, null, 2));
+    if (action === "list" && result.success !== false) {
+        // The list action prints one text line per space; every other action prints JSON.
+        if (typeof result.problem === "string")
+            stderr(result.problem);
+        stdout(spaceListLines(result).join("\n"));
+    }
+    else {
+        stdout(JSON.stringify(result, null, 2));
+    }
     return result.success === false ? 1 : 0;
 }

package/dist/cli/web-command.js

@@ -156,7 +156,7 @@ export async function runWebCommand(args, options = {}, online, handover = {}, u
     const { existsSync } = await import("node:fs");
     // Every restart onto the new copy runs the launcher, the login item's included.
     const canRestart = () => existsSync(launcherPath(ommsDir()));
-    server.setWebUpdate(startWebUpdate(() => powerAction("update"), canRestart));
+    server.setWebUpdate(startWebUpdate(() => powerAction("update"), canRestart, () => server.powerActionRunning));
     // A newer `web install` asked this web app to give up the port.
     server.setOnStepAside(async () => {
         clearInterval(keeper);

package/dist/config.js

@@ -20,6 +20,7 @@ import { checkedKeywordBoost, checkedKeywordMode, } from "./utils/keyword-boost.
 import { runLegacyStoreMigration, legacyMigrationPaths } from "./services/legacy-migration.js";
 import { expandPath, storagePathFrom, withSkillStorage, } from "./services/spaces/storage-resolution.js";
 import { resolveActiveSpace } from "./services/spaces/active-space.js";
+import { backfillSpaceLabelsFromDisk } from "./services/spaces/space-label.js";
 import { resetStoreHandles } from "./services/spaces/store-handles.js";
 const OMMS_CONFIG_DIR = join(homedir(), ".config", "omms");
 const DATA_DIR = join(homedir(), ".omms");
@@ -555,7 +556,16 @@ export function initConfig(directory, options = {}) {
     delete projectOverrides.webServerEnabled;
     const merged = { ...globalConfig, ...projectOverrides };
     // The active memory space picks the storage folder unless the project sets its own (ADR-041).
-    activeSpace = resolveActiveSpace(DATA_DIR, storagePathFrom(globalConfig), "storagePath" in projectConfig);
+    const globalStoragePath = storagePathFrom(globalConfig);
+    activeSpace = resolveActiveSpace(DATA_DIR, globalStoragePath, "storagePath" in projectConfig);
+    // The label pass repairs space.json files at the first registry read. It is
+    // metadata only, so a failure must never block start-up.
+    try {
+        backfillSpaceLabelsFromDisk(DATA_DIR, globalStoragePath);
+    }
+    catch {
+        // Best effort: the registry stays the source of truth for names.
+    }
     if (activeSpace.storagePath)
         merged.storagePath = activeSpace.storagePath;
     const nextConfig = withSkillStorage(buildConfig(merged), globalConfig);

package/dist/services/host-copies.d.ts

@@ -0,0 +1,52 @@
+/** The clean-up leaves everything alone until the running copy is this old. */
+export declare const CACHE_PRUNE_MIN_AGE_MS: number;
+export interface HostCopy {
+    /** The package folder: `.../node_modules/om-memory-system`. */
+    root: string;
+    /** The `version` in its `package.json`, or null when that cannot be read. */
+    version: string | null;
+    /** The timestamp folder name as a number (install time in ms since 1970). */
+    stamp: number;
+}
+export interface HostCopies {
+    root: string;
+    version: string | null;
+    /** The running copy's timestamp, or null when its folder is not a timestamp folder in an OpenCode cache. */
+    stamp: number | null;
+    /** Every other timestamp folder in the same cache folder. Empty without a timestamp. */
+    siblings: HostCopy[];
+}
+/**
+ * The running copy and, when it sits in a timestamp folder, the other copies in
+ * the same cache folder. Null when `modulePath` is not inside
+ * `node_modules/om-memory-system/`. Never throws.
+ */
+export declare function listHostCopies(modulePath: string): HostCopies | null;
+/**
+ * The versions on disk: the running copy's and each sibling's. Pi updates in
+ * place, so its running copy shows the new version after `pi update`. OpenCode
+ * shows it in a new sibling folder. Never throws.
+ */
+export declare function installedVersions(modulePath: string): string[];
+export interface PruneOptions {
+    modulePath: string;
+    runningVersion: string;
+    /** Package folders that must stay, such as the copy `~/.omms/runtime.json` records. */
+    keepRoots: string[];
+    now: number;
+    /** Removes a folder and everything in it. Defaults to an asynchronous `rm`, so a large folder does not block the service. */
+    remove?: (folder: string) => void | Promise<void>;
+    log: (message: string, data: Record<string, unknown>) => void | Promise<void>;
+}
+/**
+ * Remove old OMMS copies from the running copy's cache folder. A copy goes only
+ * when its timestamp and its version are both older than the running copy's,
+ * it is not in `keepRoots`, and the running copy is at least
+ * `CACHE_PRUNE_MIN_AGE_MS` old. A copy that cannot be removed stays. Logs one
+ * `OpenCode cache clean-up` record with counts for each pass in a timestamp
+ * folder, also when the counts are zero. Never throws.
+ */
+export declare function pruneOldCacheCopies(options: PruneOptions): Promise<{
+    removed: number;
+    kept: number;
+}>;