akm-cli 0.9.0-rc.1 → 0.9.0-rc.2

package/dist/core/extra-params.js

@@ -0,0 +1,61 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+export const EXTRA_PARAMS_PROTECTED_TOP_LEVEL_KEYS = [
+    "model",
+    "messages",
+    "temperature",
+    "maxtokens",
+    "responseformat",
+    "stream",
+    "streamoptions",
+    "enablethinking",
+];
+export const EXTRA_PARAMS_CREDENTIAL_KEYS = [
+    "authorization",
+    "headers",
+    "apikey",
+    "token",
+    "password",
+    "secret",
+    "cookie",
+    "setcookie",
+];
+const PROTECTED_TOP_LEVEL_KEYS = new Set(EXTRA_PARAMS_PROTECTED_TOP_LEVEL_KEYS);
+const CREDENTIAL_KEYS = new Set(EXTRA_PARAMS_CREDENTIAL_KEYS);
+export function normalizeExtraParamKey(key) {
+    return key.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+/** Validate provider extras without allowing them to override AKM fields or carry credentials. */
+export function validateExtraParams(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return [{ path: [], message: "must be an object" }];
+    }
+    const issues = [];
+    const visit = (entry, path) => {
+        if (Array.isArray(entry)) {
+            entry.forEach((child, index) => {
+                visit(child, [...path, index]);
+            });
+            return;
+        }
+        if (!entry || typeof entry !== "object")
+            return;
+        for (const [key, child] of Object.entries(entry)) {
+            const normalized = normalizeExtraParamKey(key);
+            if (path.length === 0 && PROTECTED_TOP_LEVEL_KEYS.has(normalized)) {
+                issues.push({ path: [key], message: `${key} is protected by AKM` });
+            }
+            if (CREDENTIAL_KEYS.has(normalized)) {
+                issues.push({ path: [...path, key], message: `${key} cannot carry credentials` });
+            }
+            visit(child, [...path, key]);
+        }
+    };
+    visit(value, []);
+    return issues;
+}
+export function formatExtraParamsIssue(label, issue) {
+    const suffix = issue.path.map((part) => (typeof part === "number" ? `[${part}]` : `.${part}`)).join("");
+    return `${label}${suffix} ${issue.message}`;
+}

package/dist/core/file-lock.js

@@ -1,11 +1,114 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { randomUUID } from "node:crypto";
 import fs from "node:fs";
+import path from "node:path";
+import { openDatabase } from "../storage/database.js";
 import { isProcessAlive } from "./common.js";
+function readLockSnapshot(lockPath) {
+    let fd;
+    try {
+        fd = fs.openSync(lockPath, "r");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+    try {
+        const rawContent = fs.readFileSync(fd, "utf8");
+        const stat = fs.fstatSync(fd);
+        return {
+            rawContent,
+            identity: { dev: stat.dev, ino: stat.ino, size: stat.size, mtimeMs: stat.mtimeMs },
+        };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeMs === right.mtimeMs;
+}
+function operationMutexPath(lockPath) {
+    // `.sensitive` is an established non-asset suffix across stash walkers. The
+    // mutex may sit beside a secret/env lock and must never surface as an asset.
+    return path.join(path.dirname(lockPath), `.${path.basename(lockPath)}.operations.sensitive`);
+}
+/**
+ * Serialize every mutation of one canonical lock path. SQLite's write lock is
+ * released by the OS when a process dies, so this mutex needs no stale-owner
+ * deletion protocol (which would reproduce the same check/rename race it is
+ * meant to prevent).
+ */
+function withLockOperationMutex(lockPath, run) {
+    const db = openDatabase(operationMutexPath(lockPath));
+    let began = false;
+    try {
+        db.exec("PRAGMA busy_timeout = 30000");
+        for (let attempt = 0; attempt < 5 && !began; attempt += 1) {
+            db.exec("BEGIN IMMEDIATE");
+            began = db.inTransaction;
+            if (!began)
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2 ** attempt);
+        }
+        if (!began)
+            throw new Error(`Could not acquire lock operation mutex for ${lockPath}.`);
+        const result = run();
+        db.exec("COMMIT");
+        began = false;
+        return result;
+    }
+    catch (error) {
+        if (began && db.inTransaction) {
+            try {
+                db.exec("ROLLBACK");
+            }
+            catch {
+                // Preserve the operation failure.
+            }
+        }
+        throw error;
+    }
+    finally {
+        db.close();
+    }
+}
+function tryAcquireLockRaw(lockPath, payload) {
+    try {
+        fs.writeFileSync(lockPath, payload, { flag: "wx" });
+    }
+    catch (err) {
+        if (err.code === "EEXIST")
+            return undefined;
+        throw err;
+    }
+    let snapshot;
+    try {
+        snapshot = readLockSnapshot(lockPath);
+    }
+    catch (error) {
+        releaseLockRaw(lockPath);
+        throw error;
+    }
+    if (!snapshot) {
+        releaseLockRaw(lockPath);
+        throw new Error(`Could not read newly acquired lock at ${lockPath}.`);
+    }
+    return { lockPath, ...snapshot };
+}
+function releaseLockRaw(lockPath) {
+    try {
+        fs.unlinkSync(lockPath);
+    }
+    catch {
+        // Sentinel already gone — fine.
+    }
+}
 /**
  * Atomically create a sentinel at `lockPath` with `payload` as the body.
- * Returns true if we now own the lock, false if a sentinel already
+ * Returns an exact ownership handle if we now own the lock, or undefined if a sentinel already
  * exists (EEXIST). Throws any other error (permissions, missing parent
  * dir, etc.) — callers must ensure the parent directory exists.
  *
@@ -14,15 +117,11 @@ import { isProcessAlive } from "./common.js";
  * (improve.ts records pid + startedAt so audit can correlate runs).
  */
 export function tryAcquireLockSync(lockPath, payload) {
-    try {
-        fs.writeFileSync(lockPath, payload, { flag: "wx" });
-        return true;
-    }
-    catch (err) {
-        if (err.code === "EEXIST")
-            return false;
-        throw err;
-    }
+    return withLockOperationMutex(lockPath, () => tryAcquireLockRaw(lockPath, payload));
+}
+/** Build a PID-bearing payload with a unique token for one acquisition attempt. */
+export function createLockPayload(metadata = {}) {
+    return JSON.stringify({ ...metadata, pid: process.pid, lockId: randomUUID() });
 }
 /**
  * Inspect an existing sentinel at `lockPath` without modifying it.
@@ -36,70 +135,116 @@ export function tryAcquireLockSync(lockPath, payload) {
  * Does NOT remove the file. Callers decide recovery policy.
  */
 export function probeLock(lockPath, opts) {
-    let rawContent;
-    let ageMs;
-    try {
-        rawContent = fs.readFileSync(lockPath, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return { state: "absent" };
-        return { state: "stale", reason: "unreadable" };
-    }
+    let snapshot;
     try {
-        const stat = fs.statSync(lockPath);
-        ageMs = Date.now() - stat.mtimeMs;
+        snapshot = readLockSnapshot(lockPath);
     }
     catch {
-        // Stat failed even though read succeeded — race-y removal in flight.
-        return { state: "stale", reason: "unreadable", rawContent };
+        return { state: "stale", reason: "unreadable" };
     }
+    if (!snapshot)
+        return { state: "absent" };
+    const { rawContent, identity } = snapshot;
+    const ageMs = Date.now() - identity.mtimeMs;
     const holderPid = extractHolderPid(rawContent);
     if (holderPid === undefined) {
-        return { state: "stale", reason: "invalid_pid", ageMs, rawContent };
+        return { state: "stale", reason: "invalid_pid", ageMs, rawContent, identity };
     }
     if (!isProcessAlive(holderPid)) {
-        return { state: "stale", reason: "pid_dead", holderPid, ageMs, rawContent };
+        return { state: "stale", reason: "pid_dead", holderPid, ageMs, rawContent, identity };
     }
     if (opts?.staleAfterMs !== undefined && ageMs > opts.staleAfterMs) {
-        return { state: "stale", reason: "age_exceeded", holderPid, ageMs, rawContent };
+        return { state: "stale", reason: "age_exceeded", holderPid, ageMs, rawContent, identity };
     }
-    return { state: "held", holderPid, ageMs, rawContent };
+    return { state: "held", holderPid, ageMs, rawContent, identity };
 }
 /**
- * Remove a lock file. Idempotent — silently ignores ENOENT. Used both to
- * reclaim stale locks (after probeLock returns `state: "stale"`) and to
- * release locks we own (after a successful tryAcquireLockSync).
+ * Revalidate and quarantine the probed sentinel while holding the same operation
+ * mutex used by acquisitions. A newer owner therefore cannot be renamed in the
+ * check/quarantine window, and a third contender cannot acquire until cleanup
+ * has completed.
  */
-export function releaseLock(lockPath) {
-    try {
-        fs.unlinkSync(lockPath);
-    }
-    catch {
-        // Sentinel already gone — fine.
-    }
+export function reclaimStaleLock(lockPath, probe, options) {
+    if (probe.rawContent === undefined || probe.identity === undefined)
+        return false;
+    const expectedContent = probe.rawContent;
+    const expectedIdentity = probe.identity;
+    return withLockOperationMutex(lockPath, () => {
+        let current;
+        try {
+            current = readLockSnapshot(lockPath);
+        }
+        catch {
+            return false;
+        }
+        if (!current || current.rawContent !== expectedContent || !sameIdentity(current.identity, expectedIdentity)) {
+            return false;
+        }
+        const quarantinePath = `${lockPath}.stale-${process.pid}-${randomUUID()}`;
+        try {
+            fs.renameSync(lockPath, quarantinePath);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return false;
+            throw err;
+        }
+        let quarantined;
+        try {
+            quarantined = readLockSnapshot(quarantinePath);
+        }
+        catch {
+            quarantined = undefined;
+        }
+        if (!quarantined ||
+            quarantined.rawContent !== expectedContent ||
+            !sameIdentity(quarantined.identity, expectedIdentity)) {
+            try {
+                // Restore without replacing a non-cooperating lock installed after quarantine.
+                fs.linkSync(quarantinePath, lockPath);
+            }
+            catch (err) {
+                if (err.code !== "EEXIST")
+                    throw err;
+            }
+            releaseLockRaw(quarantinePath);
+            return false;
+        }
+        options?.afterQuarantineVerified?.();
+        try {
+            fs.unlinkSync(quarantinePath);
+            return true;
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return false;
+            throw err;
+        }
+    });
 }
 /**
- * Release a lock ONLY if it is still owned by `ownerPid`. Safe to call from a
- * `process.exit()` / `'exit'` handler as a backstop: `process.exit()` skips
- * `finally` blocks — so the normal lock-release never runs on signal death
- * (SIGTERM/SIGINT) — but it DOES fire `'exit'` listeners synchronously. Checking
- * ownership first means that if the lock was already released and re-acquired by
- * a different process, this leaves that process's lock intact (no cross-run
- * deletion / PID-reuse footgun). Synchronous so it is valid inside an exit handler.
+ * Release only the exact sentinel returned by `tryAcquireLockSync`. Content and
+ * file identity are revalidated while holding the acquisition operation mutex,
+ * so a stale holder cannot remove a successor. Synchronous and idempotent so it
+ * is safe in both `finally` blocks and process exit handlers.
  */
-export function releaseLockIfOwned(lockPath, ownerPid) {
-    let rawContent;
-    try {
-        rawContent = fs.readFileSync(lockPath, "utf8");
-    }
-    catch {
-        // Absent or unreadable — nothing of ours to release.
+export function releaseLock(ownership) {
+    const { lockPath } = ownership;
+    if (!fs.existsSync(lockPath) && !fs.existsSync(operationMutexPath(lockPath)))
         return;
-    }
-    if (extractHolderPid(rawContent) === ownerPid) {
-        releaseLock(lockPath);
-    }
+    withLockOperationMutex(lockPath, () => {
+        let current;
+        try {
+            current = readLockSnapshot(lockPath);
+        }
+        catch {
+            // Absent or unreadable — nothing of ours to release.
+            return;
+        }
+        if (current && current.rawContent === ownership.rawContent && sameIdentity(current.identity, ownership.identity)) {
+            releaseLockRaw(lockPath);
+        }
+    });
 }
 /**
  * Extract a PID from a sentinel body. Accepts the two shapes used across

package/dist/core/improve-result.js

@@ -0,0 +1,178 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+const COMMON_FIELDS = [
+    "schemaVersion",
+    "ok",
+    "scope",
+    "dryRun",
+    "skipped",
+    "guidance",
+    "memorySummary",
+    "memoryCleanup",
+    "cyclesRun",
+    "plannedRefs",
+    "actions",
+    "distillSkipped",
+    "validationFailures",
+    "schemaRepairs",
+    "consolidation",
+    "extract",
+    "lintSummary",
+    "memoryIndexHealth",
+    "coverageGaps",
+    "evalCasesWritten",
+    "deadUrls",
+    "reflectsWithErrorContext",
+    "memoryInference",
+    "graphExtraction",
+    "memoryInferenceDurationMs",
+    "graphExtractionDurationMs",
+    "orphansPurged",
+    "proposalsExpired",
+    "reflectCooldownActions",
+    "reflectSkippedActions",
+    "reflectGuardRejectedActions",
+    "gateAutoAcceptedCount",
+    "gateAutoAcceptFailedCount",
+    "triage",
+    "proactiveMaintenance",
+    "recombination",
+    "proceduralCompilation",
+    "cycleMetrics",
+    "runId",
+    "sync",
+    "terminated",
+];
+const V1_FIELDS = new Set([...COMMON_FIELDS, "profile", "profileFilteredRefs"]);
+const V2_FIELDS = new Set([...COMMON_FIELDS, "strategy", "strategyFilteredRefs"]);
+function fail(message) {
+    throw new Error(`invalid improve-result envelope: ${message}`);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireExactFields(value, allowed) {
+    const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+    if (unknown.length > 0)
+        fail(`unknown field${unknown.length === 1 ? "" : "s"}: ${unknown.sort().join(", ")}`);
+}
+function validateCommon(value) {
+    if (typeof value.ok !== "boolean")
+        fail("ok must be a boolean");
+    if (typeof value.dryRun !== "boolean")
+        fail("dryRun must be a boolean");
+    if (!Array.isArray(value.plannedRefs))
+        fail("plannedRefs must be an array");
+    if (!isRecord(value.scope))
+        fail("scope must be an object");
+    requireExactFields(value.scope, new Set(["mode", "value"]));
+    if (value.scope.mode !== "all" && value.scope.mode !== "type" && value.scope.mode !== "ref") {
+        fail('scope.mode must be "all", "type", or "ref"');
+    }
+    if (value.scope.value !== undefined && typeof value.scope.value !== "string") {
+        fail("scope.value must be a string when present");
+    }
+    if (!isRecord(value.memorySummary))
+        fail("memorySummary must be an object");
+    requireExactFields(value.memorySummary, new Set(["eligible", "derived"]));
+    if (typeof value.memorySummary.eligible !== "number" || typeof value.memorySummary.derived !== "number") {
+        fail("memorySummary.eligible and memorySummary.derived must be numbers");
+    }
+    for (const field of [
+        "actions",
+        "validationFailures",
+        "schemaRepairs",
+        "extract",
+        "coverageGaps",
+        "deadUrls",
+    ]) {
+        if (value[field] !== undefined && !Array.isArray(value[field]))
+            fail(`${field} must be an array`);
+    }
+    for (const field of [
+        "cyclesRun",
+        "evalCasesWritten",
+        "reflectsWithErrorContext",
+        "memoryInferenceDurationMs",
+        "graphExtractionDurationMs",
+        "orphansPurged",
+        "proposalsExpired",
+        "reflectCooldownActions",
+        "reflectSkippedActions",
+        "reflectGuardRejectedActions",
+        "gateAutoAcceptedCount",
+        "gateAutoAcceptFailedCount",
+    ]) {
+        if (value[field] !== undefined && typeof value[field] !== "number")
+            fail(`${field} must be a number`);
+    }
+    for (const field of ["guidance", "runId"]) {
+        if (value[field] !== undefined && typeof value[field] !== "string")
+            fail(`${field} must be a string`);
+    }
+    for (const field of [
+        "skipped",
+        "memoryCleanup",
+        "distillSkipped",
+        "consolidation",
+        "lintSummary",
+        "memoryIndexHealth",
+        "memoryInference",
+        "graphExtraction",
+        "triage",
+        "proactiveMaintenance",
+        "recombination",
+        "proceduralCompilation",
+        "cycleMetrics",
+        "sync",
+        "terminated",
+    ]) {
+        if (value[field] !== undefined && !isRecord(value[field]))
+            fail(`${field} must be an object`);
+    }
+}
+/** Decode the persisted public v1/v2 contract without guessing across versions. */
+export function decodeImproveResult(input) {
+    let parsed = input;
+    if (typeof input === "string") {
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            fail("not valid JSON");
+        }
+    }
+    if (!isRecord(parsed))
+        fail("root must be an object");
+    if (parsed.schemaVersion === 1) {
+        requireExactFields(parsed, V1_FIELDS);
+        validateCommon(parsed);
+        if (parsed.profile !== undefined && typeof parsed.profile !== "string")
+            fail("profile must be a string");
+        if (parsed.profileFilteredRefs !== undefined && !Array.isArray(parsed.profileFilteredRefs)) {
+            fail("profileFilteredRefs must be an array");
+        }
+        return {
+            envelope: parsed,
+            strategy: null,
+            legacyProfile: typeof parsed.profile === "string" ? parsed.profile : null,
+        };
+    }
+    if (parsed.schemaVersion === 2) {
+        requireExactFields(parsed, V2_FIELDS);
+        validateCommon(parsed);
+        if (typeof parsed.strategy !== "string" || parsed.strategy.length === 0) {
+            fail("strategy must be a non-empty string");
+        }
+        if (parsed.strategyFilteredRefs !== undefined && !Array.isArray(parsed.strategyFilteredRefs)) {
+            fail("strategyFilteredRefs must be an array");
+        }
+        return {
+            envelope: parsed,
+            strategy: parsed.strategy,
+            legacyProfile: null,
+        };
+    }
+    fail(`unsupported schemaVersion: ${String(parsed.schemaVersion)}`);
+}

package/dist/core/maintenance-barrier.js

@@ -0,0 +1,119 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { ConfigError } from "./errors.js";
+import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "./file-lock.js";
+import { getMaintenanceBarrierPath } from "./paths.js";
+const heldBarrierContext = new AsyncLocalStorage();
+/**
+ * Serialize restore with the short critical section that creates every
+ * long-lived AKM lock or workflow lease. The long operation keeps its own
+ * lock/lease; this barrier is released immediately after acquisition.
+ */
+export function tryAcquireMaintenanceBarrier() {
+    const lockPath = getMaintenanceBarrierPath();
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: "maintenance-start" }));
+        if (ownership) {
+            return () => releaseLock(ownership);
+        }
+        const probe = probeLock(lockPath);
+        if (probe.state !== "stale" || !reclaimStaleLock(lockPath, probe))
+            return undefined;
+    }
+    return undefined;
+}
+export function acquireMaintenanceBarrier() {
+    const release = tryAcquireMaintenanceBarrier();
+    if (release)
+        return release;
+    throw new ConfigError(`AKM maintenance is in progress (barrier ${getMaintenanceBarrierPath()}); retry after it completes.`, "INVALID_CONFIG_FILE");
+}
+export function withMaintenanceStartBarrier(run) {
+    if (heldBarrierContext.getStore()?.active)
+        return run();
+    const release = acquireMaintenanceBarrier();
+    const ownership = { active: true };
+    try {
+        return heldBarrierContext.run(ownership, run);
+    }
+    finally {
+        ownership.active = false;
+        release();
+    }
+}
+async function acquireMaintenanceBarrierAsync() {
+    const deadline = Date.now() + 5_000;
+    while (true) {
+        const release = tryAcquireMaintenanceBarrier();
+        if (release)
+            return release;
+        if (Date.now() >= deadline)
+            return acquireMaintenanceBarrier();
+        await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+}
+export async function withMaintenanceStartBarrierAsync(run) {
+    if (heldBarrierContext.getStore()?.active)
+        return run();
+    const release = await acquireMaintenanceBarrierAsync();
+    const ownership = { active: true };
+    try {
+        return await heldBarrierContext.run(ownership, run);
+    }
+    finally {
+        ownership.active = false;
+        release();
+    }
+}
+function withMaintenanceStartBarrierSyncWait(run) {
+    if (heldBarrierContext.getStore()?.active)
+        return run();
+    const deadline = Date.now() + 5_000;
+    let release = tryAcquireMaintenanceBarrier();
+    while (!release && Date.now() < deadline) {
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 5);
+        release = tryAcquireMaintenanceBarrier();
+    }
+    if (!release)
+        release = acquireMaintenanceBarrier();
+    const ownership = { active: true };
+    try {
+        return heldBarrierContext.run(ownership, run);
+    }
+    finally {
+        ownership.active = false;
+        release();
+    }
+}
+/** Register a long-lived operation atomically with restore's blocker scan. */
+export async function acquireMaintenanceActivity(name) {
+    return withMaintenanceStartBarrierAsync(async () => {
+        const directory = path.join(path.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const lockPath = path.join(directory, `${name}-${process.pid}-${randomUUID()}.lock`);
+        const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
+        if (!ownership) {
+            throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
+        }
+        return () => releaseLock(ownership);
+    });
+}
+/** Synchronous activity registration for synchronous database handle lifetimes. */
+export function acquireMaintenanceActivitySync(name) {
+    return withMaintenanceStartBarrierSyncWait(() => {
+        const directory = path.join(path.dirname(getMaintenanceBarrierPath()), "maintenance-activities");
+        fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const lockPath = path.join(directory, `${name}-${process.pid}-${randomUUID()}.lock`);
+        const ownership = tryAcquireLockSync(lockPath, createLockPayload({ purpose: name }));
+        if (!ownership) {
+            throw new ConfigError(`Could not register AKM maintenance activity at ${lockPath}.`, "INVALID_CONFIG_FILE");
+        }
+        return () => releaseLock(ownership);
+    });
+}