@kisev/memomatic 1.0.0-dev.69.gd644a007a7ee → 1.0.0-dev.71.gee4e37a5bb61

package/dist/executor.js

@@ -1,11 +1,16 @@
 import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
 export function extractJson(response) {
     const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(response);
-    const candidates = [fenced?.[1], response].filter(Boolean);
-    for (const candidate of candidates) {
+    for (const candidate of [fenced?.[1], response]) {
+        if (!candidate)
+            continue;
         const start = candidate.indexOf("{");
         const end = candidate.lastIndexOf("}");
-        if (start === -1 || end <= start)
+        if (start < 0 || end <= start)
             continue;
         try {
             return JSON.parse(candidate.slice(start, end + 1));
@@ -19,60 +24,266 @@ export function extractJson(response) {
 export class OpenCodeExecutor {
     options;
     name = "opencode";
+    usage = {
+        calls: 0,
+        retries: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadTokens: 0,
+        cacheWriteTokens: 0,
+        usageAvailable: false,
+        charactersSent: 0,
+    };
+    child;
+    directory;
+    url;
+    authorization;
     constructor(options) {
         this.options = options;
     }
+    async initialize() {
+        if (this.url)
+            return;
+        if (this.options.url) {
+            const url = new URL(this.options.url);
+            if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+                throw new Error("invalid OpenCode URL");
+            this.url = url.href.replace(/\/$/, "");
+            if (process.env.OPENCODE_SERVER_PASSWORD)
+                this.authorization = `Basic ${Buffer.from(`${process.env.OPENCODE_SERVER_USERNAME ?? "opencode"}:${process.env.OPENCODE_SERVER_PASSWORD}`).toString("base64")}`;
+            return;
+        }
+        let inherited = {};
+        if (process.env.OPENCODE_CONFIG_CONTENT) {
+            try {
+                const value = JSON.parse(process.env.OPENCODE_CONFIG_CONTENT);
+                if (!value || typeof value !== "object" || Array.isArray(value))
+                    throw new Error();
+                inherited = value;
+            }
+            catch {
+                throw new Error("OpenCode inline configuration must be a JSON object");
+            }
+        }
+        this.directory = await mkdtemp(join(tmpdir(), "memomatic-opencode-"));
+        const password = randomBytes(24).toString("hex");
+        this.authorization = `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}`;
+        this.options.observe?.({
+            phase: "opencode.start",
+            message: "Starting one isolated OpenCode server for this run",
+        });
+        const child = spawn(this.options.binary ?? "opencode", ["serve", "--hostname", "127.0.0.1", "--port", "0", "--pure"], {
+            cwd: this.directory,
+            detached: process.platform !== "win32",
+            stdio: ["ignore", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                OPENCODE_SERVER_USERNAME: "opencode",
+                OPENCODE_SERVER_PASSWORD: password,
+                OPENCODE_DISABLE_PROJECT_CONFIG: "1",
+                OPENCODE_DISABLE_EXTERNAL_SKILLS: "1",
+                OPENCODE_DISABLE_CLAUDE_CODE_SKILLS: "1",
+                OPENCODE_DISABLE_DEFAULT_PLUGINS: "1",
+                OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                    ...inherited,
+                    permission: "deny",
+                    tools: { "*": false },
+                    agent: {
+                        ...inherited.agent,
+                        memomatic: {
+                            mode: "primary",
+                            description: "Bounded memory extraction",
+                            prompt: "Return only the requested JSON. Do not use tools.",
+                            permission: "deny",
+                            tools: { "*": false },
+                        },
+                    },
+                }),
+            },
+        });
+        this.child = child;
+        this.url = await new Promise((resolve, reject) => {
+            let output = "";
+            const timeout = setTimeout(() => done(new Error("OpenCode startup timed out")), 30000);
+            const abort = () => done(this.options.signal?.reason instanceof Error
+                ? this.options.signal.reason
+                : new Error("interrupted"));
+            const failed = (error) => done(error);
+            const closed = () => done(new Error("OpenCode exited before becoming ready"));
+            const data = (chunk) => {
+                output = (output + chunk.toString()).slice(-8192);
+                const match = /https?:\/\/127\.0\.0\.1:\d+/.exec(output);
+                if (match)
+                    done(undefined, match[0]);
+            };
+            const done = (error, url) => {
+                clearTimeout(timeout);
+                child.stdout?.off("data", data);
+                child.stderr?.off("data", data);
+                child.off("error", failed);
+                child.off("exit", closed);
+                this.options.signal?.removeEventListener("abort", abort);
+                if (error)
+                    reject(error);
+                else
+                    resolve(url);
+            };
+            child.stdout?.on("data", data);
+            child.stderr?.on("data", data);
+            child.once("error", failed);
+            child.once("exit", closed);
+            this.options.signal?.addEventListener("abort", abort, { once: true });
+            if (this.options.signal?.aborted)
+                abort();
+        });
+        // Drain logs without retaining provider output, credentials or prompts.
+        child.stdout?.resume();
+        child.stderr?.resume();
+        this.options.observe?.({ phase: "opencode.ready", message: "OpenCode server ready" });
+    }
+    async request(path, body, signal) {
+        const response = await fetch(`${this.url}${path}`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                ...(this.authorization ? { authorization: this.authorization } : {}),
+            },
+            body: JSON.stringify(body),
+            signal,
+        });
+        if (!response.ok)
+            throw new Error(`OpenCode ${path.includes("message") ? "model request" : "session request"} failed: HTTP ${response.status}`);
+        return (await response.json());
+    }
     async complete(request) {
-        const args = ["run", "--agent", "build", "--format", "json"];
-        if (this.options.model)
-            args.push("--model", this.options.model);
-        if (this.options.variant)
-            args.push("--variant", this.options.variant);
-        args.push("--", `[memomatic-internal] ${request.system}\n\n${request.prompt}`);
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            const output = await this.spawnOnce(args);
+        this.options.signal?.throwIfAborted();
+        await this.initialize();
+        for (let attempt = 0; attempt <= (this.options.retries ?? 1); attempt++) {
+            this.options.signal?.throwIfAborted();
+            const signal = AbortSignal.any([
+                AbortSignal.timeout(this.options.timeoutMs ?? 180000),
+                ...(this.options.signal ? [this.options.signal] : []),
+            ]);
+            let id;
+            const started = Date.now();
+            const heartbeat = setInterval(() => this.options.observe?.({
+                phase: "model.wait",
+                message: "Waiting for OpenCode/model response",
+                elapsedMs: Date.now() - started,
+                attempt: attempt + 1,
+            }), 15000);
+            heartbeat.unref();
             try {
-                const texts = [];
-                for (const line of output.split("\n")) {
-                    if (!line.trim())
-                        continue;
-                    const event = JSON.parse(line);
-                    if (event.type === "error")
-                        throw new Error("opencode returned an error event");
-                    if (event.type === "text" && typeof event.part?.text === "string")
-                        texts.push(event.part.text);
+                const session = await this.request("/session", {
+                    title: "[memomatic-internal] memory extraction",
+                    permission: [{ permission: "*", pattern: "*", action: "deny" }],
+                }, signal);
+                if (typeof session.id !== "string")
+                    throw new Error("OpenCode session response is malformed");
+                id = session.id;
+                const slash = this.options.model?.indexOf("/") ?? -1;
+                if (this.options.model && slash < 1)
+                    throw new Error("model must use provider/model format");
+                this.usage.calls++;
+                this.usage.charactersSent += request.system.length + request.prompt.length;
+                this.options.observe?.({
+                    phase: "model.request",
+                    message: "Sending prepared fragment to OpenCode",
+                    characters: request.prompt.length,
+                    attempt: attempt + 1,
+                });
+                const response = await this.request(`/session/${encodeURIComponent(id)}/message`, {
+                    agent: this.options.url ? "build" : "memomatic",
+                    system: request.system,
+                    tools: { "*": false },
+                    ...(this.options.model
+                        ? {
+                            model: {
+                                providerID: this.options.model.slice(0, slash),
+                                modelID: this.options.model.slice(slash + 1),
+                            },
+                        }
+                        : {}),
+                    ...(this.options.variant ? { variant: this.options.variant } : {}),
+                    parts: [{ type: "text", text: `[memomatic-internal] ${request.prompt}` }],
+                }, signal);
+                const info = response.info;
+                if (info?.error)
+                    throw new Error("OpenCode model returned an error; inspect the configured provider");
+                if (info?.tokens) {
+                    this.usage.usageAvailable = true;
+                    this.usage.inputTokens += info.tokens.input ?? 0;
+                    this.usage.outputTokens += info.tokens.output ?? 0;
+                    this.usage.cacheReadTokens += info.tokens.cache?.read ?? 0;
+                    this.usage.cacheWriteTokens += info.tokens.cache?.write ?? 0;
                 }
-                const parsed = extractJson(texts.join("\n"));
+                const parts = response.parts;
+                if (!Array.isArray(parts))
+                    throw new Error("OpenCode model response is malformed");
+                const parsed = extractJson(parts
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text ?? "")
+                    .join("\n"));
+                this.options.observe?.({
+                    phase: "model.done",
+                    message: "Model response received",
+                    elapsedMs: Date.now() - started,
+                    ...this.usage,
+                });
                 return JSON.stringify(parsed);
             }
-            catch {
-                if (attempt === 1)
-                    throw new Error("opencode run returned no parsable JSON twice");
+            catch (error) {
+                if (id)
+                    await this.request(`/session/${encodeURIComponent(id)}/abort`, {}, AbortSignal.timeout(3000)).catch(() => undefined);
+                if (this.options.signal?.aborted)
+                    throw this.options.signal.reason;
+                if (attempt === (this.options.retries ?? 1))
+                    throw new Error(`OpenCode request failed after ${attempt + 1} attempt(s): ${error.message}`);
+                this.usage.retries++;
+                this.options.observe?.({
+                    phase: "model.retry",
+                    message: "Retrying failed model request",
+                    level: "warn",
+                    attempt: attempt + 2,
+                    reason: error.message,
+                });
+            }
+            finally {
+                clearInterval(heartbeat);
             }
         }
         throw new Error("unreachable");
     }
-    spawnOnce(args) {
-        return new Promise((resolve, reject) => {
-            const child = spawn(this.options.binary ?? "opencode", args, {
-                env: process.env,
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-            let stdout = "";
-            let stderr = "";
-            child.stdout.on("data", (chunk) => {
-                stdout += chunk.toString("utf8");
-            });
-            child.stderr.on("data", (chunk) => {
-                stderr += chunk.toString("utf8");
-            });
-            child.on("error", reject);
-            child.on("close", (code) => {
-                if (code === 0)
-                    resolve(stdout);
-                else
-                    reject(new Error(`opencode run exited ${code}: ${stderr.slice(0, 400)}`));
+    async close() {
+        const child = this.child;
+        if (child?.pid && child.exitCode === null && child.signalCode === null) {
+            await new Promise((resolve) => {
+                const kill = (signal) => {
+                    try {
+                        if (process.platform !== "win32" && child.pid)
+                            process.kill(-child.pid, signal);
+                        else
+                            child.kill(signal);
+                    }
+                    catch { }
+                };
+                const timer = setTimeout(() => kill("SIGKILL"), 1000);
+                timer.unref();
+                child.once("close", () => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+                kill("SIGTERM");
             });
-        });
+        }
+        if (child?.pid && process.platform !== "win32") {
+            try {
+                process.kill(-child.pid, "SIGKILL");
+            }
+            catch { }
+        }
+        this.child = undefined;
+        if (this.directory)
+            await rm(this.directory, { recursive: true, force: true });
     }
 }

package/dist/generated/cli.d.ts

@@ -0,0 +1,28 @@
+import { Command, Option, CommanderError, InvalidArgumentError } from "commander";
+export { Command, Option, CommanderError, InvalidArgumentError };
+export declare function integer(value: string): number;
+export declare function duration(value: string): number;
+export declare function program(name: string, description: string, version: string): Command;
+export declare function common(command: Command, prefix: string): Command;
+export declare function configFile(path: string | undefined): Promise<Record<string, unknown>>;
+export declare function configFileSync(path: string | undefined): Record<string, unknown>;
+export declare function applyConfig(command: Command, config: Record<string, unknown>): void;
+export type Event = {
+    phase: string;
+    message: string;
+    level?: "debug" | "info" | "warn" | "error";
+    completed?: number;
+    total?: number;
+    elapsedMs?: number;
+    [key: string]: unknown;
+};
+export type Observe = (event: Event) => void;
+export declare function reporter(options?: Record<string, unknown>): {
+    emit: Observe;
+    close: () => void;
+};
+export declare function cancellation(): {
+    signal: AbortSignal;
+    dispose: () => void;
+};
+export declare function fail(name: string, error: unknown, json?: boolean): void;

package/dist/generated/cli.js

@@ -0,0 +1,181 @@
+import { Command, Option, CommanderError, InvalidArgumentError } from "commander";
+import { readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+export { Command, Option, CommanderError, InvalidArgumentError };
+export function integer(value) {
+    if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)))
+        throw new InvalidArgumentError("expected a non-negative integer");
+    return Number(value);
+}
+export function duration(value) {
+    const match = /^(\d+)(ms|s|m|h)?$/.exec(value);
+    if (!match)
+        throw new InvalidArgumentError("expected a duration such as 500ms, 30s or 5m");
+    const result = Number(match[1]) * ({ ms: 1, s: 1000, m: 60000, h: 3600000 }[match[2] ?? "ms"] ?? 1);
+    if (!Number.isSafeInteger(result) || result < 0)
+        throw new InvalidArgumentError("duration is out of range");
+    return result;
+}
+export function program(name, description, version) {
+    return new Command(name)
+        .description(description)
+        .version(version)
+        .exitOverride()
+        .configureHelp({ showGlobalOptions: true })
+        .showHelpAfterError()
+        .configureOutput({ outputError: () => { } });
+}
+export function common(command, prefix) {
+    return command
+        .addOption(new Option("--config <file>", "JSON configuration file (CLI > env > file > defaults)").env(`${prefix}_CONFIG`))
+        .addOption(new Option("--json", "machine-readable result on stdout").env(`${prefix}_JSON`))
+        .addOption(new Option("--log-level <level>", "diagnostic verbosity on stderr")
+        .choices(["debug", "info", "warn", "error", "silent"])
+        .env(`${prefix}_LOG_LEVEL`))
+        .addOption(new Option("--log-format <format>", "diagnostic format on stderr")
+        .choices(["text", "json"])
+        .env(`${prefix}_LOG_FORMAT`))
+        .addOption(new Option("--progress <mode>", "terminal progress; never written to stdout")
+        .choices(["auto", "always", "never"])
+        .env(`${prefix}_PROGRESS`))
+        .addOption(new Option("--color <mode>", "color policy (NO_COLOR disables color)")
+        .choices(["auto", "always", "never"])
+        .env(`${prefix}_COLOR`));
+}
+export async function configFile(path) {
+    if (!path)
+        return {};
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new InvalidArgumentError("configuration must be a JSON object");
+    return value;
+}
+export function configFileSync(path) {
+    if (!path)
+        return {};
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new InvalidArgumentError("configuration must be a JSON object");
+    return value;
+}
+export function applyConfig(command, config) {
+    for (const option of command.options) {
+        const key = option.attributeName();
+        if (!(key in config) || ["cli", "env"].includes(command.getOptionValueSource(key) ?? ""))
+            continue;
+        if (["yes", "config"].includes(key))
+            continue;
+        const value = config[key];
+        if (option.required || option.optional) {
+            const raw = String(value);
+            if (option.argChoices && !option.argChoices.includes(raw))
+                throw new InvalidArgumentError(`invalid configuration value for ${key}`);
+            command.setOptionValueWithSource(key, option.parseArg ? option.parseArg(raw, undefined) : raw, "config");
+        }
+        else {
+            if (typeof value !== "boolean")
+                throw new InvalidArgumentError(`${key} must be boolean`);
+            command.setOptionValueWithSource(key, value, "config");
+        }
+    }
+}
+export function reporter(options = {}) {
+    const started = Date.now();
+    const level = String(options.logLevel ?? "info");
+    const levels = ["debug", "info", "warn", "error", "silent"];
+    const json = options.logFormat === "json";
+    const interactive = !json &&
+        options.progress !== "never" &&
+        (options.progress === "always" || process.stderr.isTTY);
+    let current;
+    let painted = false;
+    let frame = 0;
+    let meter;
+    const bar = () => {
+        if (!meter || meter.total <= 0)
+            return "";
+        const ratio = Math.min(1, Math.max(0, meter.completed / meter.total));
+        const filled = Math.floor(ratio * 16);
+        return ` | ${meter.phase} [${"█".repeat(filled)}${"░".repeat(16 - filled)}] ${Math.floor(ratio * 100)}%`;
+    };
+    const clean = (text) => Array.from(text, (char) => {
+        const code = char.codePointAt(0);
+        return code < 32 || (code >= 127 && code <= 159) ? " " : char;
+    }).join("");
+    const line = (event) => `${event.phase}: ${event.message}${event.total !== undefined ? ` [${event.completed ?? 0}/${event.total}]` : ""} (${Math.floor((Date.now() - started) / 1000)}s)`;
+    const clear = () => {
+        if (painted) {
+            process.stderr.write("\r\x1b[2K");
+            painted = false;
+        }
+    };
+    const timer = interactive && level !== "silent"
+        ? setInterval(() => {
+            if (current) {
+                const color = process.env.NO_COLOR === undefined &&
+                    (options.color === "always" || (options.color !== "never" && process.stderr.isTTY));
+                process.stderr.write(`\r\x1b[2K${color ? "\x1b[36m" : ""}${["⠋", "⠙", "⠹", "⠸"][frame++ % 4]} ${clean(line(current))}${bar()}${color ? "\x1b[0m" : ""}`);
+                painted = true;
+            }
+        }, 120)
+        : undefined;
+    timer?.unref();
+    const emit = (event) => {
+        const severity = event.level ?? "info";
+        if (levels.indexOf(severity) < levels.indexOf(level))
+            return;
+        current = event;
+        if (event.total !== undefined)
+            meter =
+                event.total > 0
+                    ? {
+                        phase: event.phase.split(".")[0],
+                        completed: event.completed ?? 0,
+                        total: event.total,
+                    }
+                    : undefined;
+        else if (meter && meter.completed >= meter.total)
+            meter = undefined;
+        clear();
+        process.stderr.write(json
+            ? `${JSON.stringify({ at: new Date().toISOString(), elapsedMs: Date.now() - started, ...event })}\n`
+            : `${clean(line(event))}\n`);
+    };
+    return {
+        emit,
+        close: () => {
+            if (timer)
+                clearInterval(timer);
+            clear();
+        },
+    };
+}
+export function cancellation() {
+    const controller = new AbortController();
+    const interrupt = () => controller.abort(new Error("interrupted"));
+    process.on("SIGINT", interrupt);
+    process.on("SIGTERM", interrupt);
+    process.on("SIGHUP", interrupt);
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", interrupt);
+            process.off("SIGHUP", interrupt);
+        },
+    };
+}
+export function fail(name, error, json = false) {
+    if (error instanceof CommanderError && error.exitCode === 0)
+        return;
+    const message = error instanceof Error ? error.message : String(error);
+    const interrupted = /interrupted|aborted/i.test(message);
+    process.stderr.write(json ? `${JSON.stringify({ status: "error", message })}\n` : `${name}: ${message}\n`);
+    process.exitCode = /timeout|timed out|deadline/i.test(message)
+        ? 124
+        : interrupted
+            ? 130
+            : error instanceof CommanderError
+                ? 2
+                : 1;
+}

package/dist/inbox.d.ts

@@ -1,3 +1,4 @@
+import { type OperationOptions } from "./operations.js";
 import type { MemomaticContext } from "./service.js";
 import type { MemomaticPaths } from "./paths.js";
 export type InboxReport = {
@@ -22,8 +23,9 @@ export declare function dropToInbox(paths: MemomaticPaths, lines: string[], sour
  * deduplicate exact texts, supersede entries sharing a key, route user-origin
  * targets, then rebuild the index with embeddings. No model turns.
  */
-export declare function processInbox(context: MemomaticContext, options?: {
+export declare function processInbox(context: MemomaticContext, options?: OperationOptions & {
     dryRun?: boolean;
+    deferIndex?: boolean;
 }): Promise<InboxReport>;
 /**
  * Serialize whole runs (dream or process) with a stale-tolerant lock file so a

package/dist/inbox.js

@@ -1,6 +1,7 @@
 import { mkdir, open, readdir, rename, rm, unlink } from "node:fs/promises";
 import { join } from "node:path";
 import { randomBytes } from "node:crypto";
+import { check } from "./operations.js";
 import { writeAtomic } from "@kisev/safe-fs";
 import { appendDailyEntry, readTextIfExists, replaceEntryLine, writeCorpusFile } from "./corpus.js";
 import { entryLine, parseEntryLine } from "./entries.js";
@@ -87,6 +88,13 @@ export async function processInbox(context, options = {}) {
         return report;
     const corpus = await scanCorpus(context.paths);
     for (const name of names) {
+        check(options);
+        options.observe?.({
+            phase: "inbox",
+            message: "Processing inbox file",
+            completed: report.filesProcessed + report.filesRejected,
+            total: names.length,
+        });
         const markdown = (await readTextIfExists(join(context.paths.inboxDir, name))) ?? "";
         const rawLines = markdown.split("\n");
         const parsedLines = rawLines.filter((line) => line.trim()).map((line) => parseEntryLine(line));
@@ -108,6 +116,7 @@ export async function processInbox(context, options = {}) {
         }
         let accepted = false;
         for (const parsed of allowed) {
+            check(options);
             if (corpus.texts.has(parsed.text)) {
                 report.entriesDuplicated += 1;
                 continue;
@@ -151,8 +160,8 @@ export async function processInbox(context, options = {}) {
             report.filesRejected += 1;
         }
     }
-    if (!dryRun)
-        await reindex(context.paths, context.settings, context.store);
+    if (!dryRun && !options.deferIndex)
+        await reindex(context.paths, context.settings, context.store, options);
     return report;
 }
 /**
@@ -160,11 +169,12 @@ export async function processInbox(context, options = {}) {
  * nightly sweep and a manual CLI invocation never mutate the corpus together.
  */
 export async function withRunLock(paths, work) {
+    const owner = `${process.pid} ${new Date().toISOString()} ${randomBytes(12).toString("hex")}\n`;
     const acquire = async () => {
         try {
             const handle = await open(paths.runLockFile, "wx", 0o600);
             try {
-                await handle.writeFile(`${process.pid} ${new Date().toISOString()}\n`);
+                await handle.writeFile(owner);
             }
             finally {
                 await handle.close();
@@ -178,14 +188,24 @@ export async function withRunLock(paths, work) {
                 const handle = await open(paths.runLockFile, "r");
                 try {
                     const info = await handle.stat();
-                    stale = Date.now() - info.mtimeMs > LOCK_STALE_MS;
+                    const owner = Number.parseInt((await handle.readFile("utf8")).split(" ")[0], 10);
+                    if (Number.isSafeInteger(owner) && owner > 0) {
+                        try {
+                            process.kill(owner, 0);
+                        }
+                        catch (cause) {
+                            stale = cause.code === "ESRCH";
+                        }
+                    }
+                    else
+                        stale = Date.now() - info.mtimeMs > LOCK_STALE_MS;
                 }
                 finally {
                     await handle.close();
                 }
             }
             catch {
-                return;
+                return acquire();
             }
             if (!stale)
                 throw new Error("another memomatic run is active");
@@ -198,6 +218,7 @@ export async function withRunLock(paths, work) {
         return await work();
     }
     finally {
-        await rm(paths.runLockFile, { force: true }).catch(() => undefined);
+        if ((await readTextIfExists(paths.runLockFile)) === owner)
+            await rm(paths.runLockFile, { force: true }).catch(() => undefined);
     }
 }

package/dist/ingest.d.ts

@@ -1,16 +1 @@
-export type IngestSession = {
-    id: string;
-    title: string;
-    directory: string;
-    timeCreated: number;
-    messages: Array<{
-        role: string;
-        text: string;
-    }>;
-};
 export declare function opencodeDatabasePath(): string;
-export declare function loadRecentSessions(databaseFile: string, afterTimeCreated: number, options?: {
-    maxSessions: number;
-    maxCharsPerSession: number;
-    before?: number;
-}): IngestSession[];