@yandy0725/memory-core 2.0.1 → 2.1.0

package/src/config.ts

@@ -52,6 +52,51 @@ export interface ExtractMemoriesConfig {
 	maxAssistantChars: number;
 }
 
+/**
+ * 跨设备同步的配置子树。
+ *
+ * 这里**只**收两个宿主共有的语义（core 的配置契约不收单宿主策略键，同 `dream` 的触发策略归宿主）：
+ * 凡是只有一侧能可靠挂上的接线细节（比如退出时再推一次）就**不设键**，而不是设一个「配了不生效」的键。
+ *
+ * 本节不触碰文件系统：core 只给默认值与合并语义，配置由适配层从自己的配置源读出后交给 `mergeConfig`。
+ */
+export interface SyncConfig {
+	/**
+	 * opt-in：自动往远端写数据必须由用户显式承担（同 `extractMemories`）。
+	 *
+	 * **必须是布尔值**，而且消费方一律按 `=== true` 判定：这是一道**同意边界**，不是类型洁癖。
+	 * 配置从宿主的 JSON 直接合并进来（`mergeConfig` 不校验类型），而 `"false"` 这种字符串在 JS 里
+	 * 是真值 —— 按真值判定就会把用户明写的「关」读成「开」，记忆继续往远端推，而校验出口还报「没问题」。
+	 * 不为 `true` 时其余键一律不校验（见 `syncConfigErrors`）。
+	 */
+	enabled: boolean;
+	/** git 远端 URL：只供首次初始化用；初始化之后的真相来源是暂存 clone 的 origin。 */
+	remote: string;
+	/** 远端的跟踪分支名。 */
+	branch: string;
+	/**
+	 * 会话开始时自动收敛远端变更并补推（一轮 push 同时包含 pull 与发布）。
+	 * 键名保留既有配置契约，不因为启动入口是 push 就改名；同样是 `=== true` 才算开（见 `enabled`）。
+	 */
+	pullOnStart: boolean;
+	/** 写入后去抖自动发布。同样是 `=== true` 才算开（见 `enabled`）。 */
+	pushOnWrite: boolean;
+	/**
+	 * 写入触发的静默期：静默期内的多条写入合并成一次推送（一轮 dream 写十几个文件 → 一次推送）。
+	 * 它是**两个宿主共有**的语义（两边的写触发都按它去抖），所以属于 core；退出兜底那种只有一侧
+	 * 能可靠挂上的接线细节则不设键。
+	 */
+	pushDebounceMs: number;
+	/**
+	 * 自动路径（会话开始的拉取、退出兜底的推）每次 git 子进程的时间上限。
+	 * 与 `timeoutMs` 分两档是刻意的：自动路径被 await 在会话启动路径上，离线 / 连不上远端时若按
+	 * 手动档计时，每开一次会话都要白等满 20s（一轮至少两次子进程）。自动档取短。
+	 */
+	autoTimeoutMs: number;
+	/** 手动命令（用户正在等结果）每次 git 子进程的时间上限，比自动档宽。 */
+	timeoutMs: number;
+}
+
 export interface MemoryConfig {
 	/** Shared defaults for model and sessionPersistence. Per-task configs override. */
 	defaults?: DefaultsConfig;
@@ -92,6 +137,11 @@ export interface MemoryConfig {
 	extractMemories: ExtractMemoriesConfig & {
 		sessionPersistence?: SessionPersistenceConfig;
 	};
+	/**
+	 * 跨设备同步。校验出口是 `syncConfigErrors`，**非** `modelConfigErrors`：后者被消费成
+	 * 「整个记忆层不可用」，少写一个远端 URL 不该有这个代价（同设计里的降级铁律）。
+	 */
+	sync: SyncConfig;
 }
 
 export const DEFAULT_CONFIG: MemoryConfig = {
@@ -123,6 +173,20 @@ export const DEFAULT_CONFIG: MemoryConfig = {
 		maxToolResultChars: 500,
 		maxAssistantChars: 2000,
 	},
+	sync: {
+		// 自动往远端写数据必须由用户显式承担：默认关闭（同 extractMemories）。
+		enabled: false,
+		// 空 remote 只在 enabled 为真时才算错（见 syncConfigErrors）：默认关闭时它只是占位。
+		remote: "",
+		branch: "main",
+		pullOnStart: true,
+		pushOnWrite: true,
+		// 一轮 dream 写十几个文件 → 去抖后只推送一次。
+		pushDebounceMs: 5000,
+		// 自动档 5s / 手动档 20s：自动路径在会话启动上被 await，不能让离线把每次启动拖满。
+		autoTimeoutMs: 5000,
+		timeoutMs: 20000,
+	},
 };
 
 /** 需要显式模型的子任务。顺序固定：dream → extractMemories → autoSurfacing（校验信息按此顺序输出）。 */
@@ -186,6 +250,63 @@ export function modelConfigErrors(
 	return errors;
 }
 
+/**
+ * 同步配置的校验出口，**非致命**（形状仿 `modelConfigErrors`，但刻意是另一个函数）。
+ *
+ * 为什么不并进 `modelConfigErrors`：那条路的唯一消费者会把配置错误当成「整个记忆层不可用」——
+ * 不解析目录、不建 store、不注册工具、没有索引段。少写一个远端 URL 不该让用户丢掉全部记忆功能，
+ * 所以收到非空列表的适配层只需把同步当成未启用并报出来，其余记忆功能照常。
+ *
+ * 三个布尔键**无条件**校验类型（它们就是开关本身，包括 `enabled`）；其余键只在 `enabled === true`
+ * 时才检查：关掉的开关不该逼用户先去修它管辖的键。
+ * 顺序固定：enabled → pullOnStart → pushOnWrite → remote → branch → pushDebounceMs → autoTimeoutMs
+ * → timeoutMs；每条消息都点名键，便于直接改配置。
+ * `options.initialized === true` 时本地 origin 已是远端真相来源，因此只放宽 remote 为空这一条，
+ * 其余键与同意边界的校验完全不变。
+ */
+export function syncConfigErrors(cfg: MemoryConfig, options: { initialized?: boolean } = {}): string[] {
+	const sync = cfg.sync;
+	// 读不懂的子树（`deepMerge` 会把用户写的 `"sync": null`、甚至一个字符串原样带进来）按「未启用」
+	// 处理，一条都不报：没有键可校验，也没有开关可开。不抛 TypeError 是底线。
+	if (typeof sync !== "object" || sync === null) return [];
+
+	const errors: string[] = [];
+	// 三个布尔键按**类型**校验，不按真值：`"enabled": "false"` 在 JS 里是真值，
+	// 只判真值的话用户明写的「关」会被当成「开」，而这个函数还返回空数组（= 配置没问题）。
+	// 自动往远端推数据必须由用户显式承担，所以「不是明确的 true」一律按关处理并报出来。
+	for (const key of ["enabled", "pullOnStart", "pushOnWrite"] as const) {
+		const value: unknown = sync[key];
+		if (typeof value !== "boolean") {
+			const shown = typeof value === "string" ? JSON.stringify(value) : String(value);
+			errors.push(`sync is disabled because "sync.${key}" must be true or false (got ${shown})`);
+		}
+	}
+	// 不是明确的 true 就到此为止：开关没开，它管辖的键不必逼用户先修（与消费方 `=== true` 同口径）。
+	if (sync.enabled !== true) return errors;
+
+	// 非字符串是类型错误，不是「空」；initialized 只豁免空字符串。先查类型，避免 `.trim()` 把校验变成崩溃。
+	if (typeof sync.remote !== "string") {
+		errors.push(
+			`sync is enabled but "sync.remote" must be a string (got ${String(sync.remote)}) — set a remote URL or unset "sync.enabled"`,
+		);
+	} else if (options.initialized !== true && sync.remote.trim() === "") {
+		errors.push('sync is enabled but "sync.remote" is empty — set "sync.remote" in memory.json or unset "sync.enabled"');
+	}
+	if (typeof sync.branch !== "string" || sync.branch.trim() === "") {
+		errors.push('sync is enabled but "sync.branch" is empty — set a branch name or unset "sync.enabled"');
+	}
+	for (const key of ["pushDebounceMs", "autoTimeoutMs", "timeoutMs"] as const) {
+		const value: unknown = sync[key];
+		// 类型也在这里查：`mergeConfig` 不校验类型，手写的配置里 `"5000"` 会一路传到定时器 /
+		// 子进程的 budget 上，那时是一句看不懂的失败而不是一条可读错误。
+		if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+			const shown = typeof value === "string" ? JSON.stringify(value) : String(value);
+			errors.push(`sync is enabled but "sync.${key}" must be a positive number of milliseconds (got ${shown})`);
+		}
+	}
+	return errors;
+}
+
 /** 已通过启动校验的模型值；缺失时抛错（真正的守卫在适配层的会话启动路径上，这里是防御）。 */
 export function requiredModel(cfg: MemoryConfig, task: ModelTask): string {
 	const value = taskModel(cfg, task);

package/src/index.ts

@@ -23,11 +23,25 @@ export {
 } from "./store/entry-index.js";
 export type { IndexCapacity, IndexLineEntry, ParsedEntryIndex } from "./store/entry-index.js";
 
-export { ENTRY_EXT, entryFileName, resolveUniqueFileName } from "./store/filename.js";
+export {
+	ENTRY_EXT,
+	entryFileName,
+	foldFileName,
+	isEntryFileNameForRead,
+	isEntryFileNameForWrite,
+	resolveUniqueFileName,
+} from "./store/filename.js";
 
 // ── store/ 读写门面 ────────────────────────────────────────────────────────────
-export { BACKUP_DIR, LOCK_FILE, MemoryStore } from "./store/memory-store.js";
-export type { Entry, EntrySummary, StoreConfig, WriteOptions } from "./store/memory-store.js";
+export { BACKUP_DIR, INDEX_FILE, LOCK_FILE, MemoryStore } from "./store/memory-store.js";
+export type {
+	ApplyChange,
+	ApplyResult,
+	Entry,
+	EntrySummary,
+	StoreConfig,
+	WriteOptions,
+} from "./store/memory-store.js";
 
 // ── store/ 并发与容错 ──────────────────────────────────────────────────────────
 export { MemoryLockedError, readLockStatus, tryWithLock, withLock } from "./store/fs-lock.js";
@@ -36,7 +50,12 @@ export type { LockInfo, LockOptions } from "./store/fs-lock.js";
 export { isTransientFsError, withFsRetry } from "./store/fs-retry.js";
 export type { FsRetryOptions } from "./store/fs-retry.js";
 
-export { ProcessLockTimeoutError, isProcessLockActive, tryWithProcessLock, withProcessLock } from "./store/process-lock.js";
+export {
+	ProcessLockTimeoutError,
+	isProcessLockActive,
+	tryWithProcessLock,
+	withProcessLock,
+} from "./store/process-lock.js";
 
 export { createSnapshot, pruneSnapshots, snapshotStamp } from "./store/snapshot.js";
 export type { SnapshotOptions } from "./store/snapshot.js";
@@ -44,7 +63,13 @@ export type { SnapshotOptions } from "./store/snapshot.js";
 export { withFileMutationQueue } from "./store/mutation-queue.js";
 
 // ── store/ 路径与安全 ──────────────────────────────────────────────────────────
-export { assertInsideRoot, normalizeRemoteUrl, projectDirName, projectIdentity, resolveMemoryDir } from "./store/paths.js";
+export {
+	assertInsideRoot,
+	normalizeRemoteUrl,
+	projectDirName,
+	projectIdentity,
+	resolveMemoryDir,
+} from "./store/paths.js";
 export type { NamingOptions, ProjectIdentity, ProjectKind } from "./store/paths.js";
 
 export { sanitizeForInjection, stripInvisibleChars } from "./store/sanitize.js";
@@ -61,6 +86,7 @@ export {
 	modelConfigErrors,
 	requiredModel,
 	requiredModels,
+	syncConfigErrors,
 	taskModel,
 } from "./config.js";
 export type {
@@ -71,6 +97,7 @@ export type {
 	MemoryConfig,
 	ModelTask,
 	SessionPersistenceConfig,
+	SyncConfig,
 	ThinkLevel,
 } from "./config.js";
 
@@ -144,3 +171,72 @@ export type {
 	MemoryHandlerDeps,
 	MemoryHandlerOptions,
 } from "./tool/handler.js";
+
+// ── sync/ 跨设备同步 ──────────────────────────────────────────────────────────
+// 适配层只从这里拿同步能力：装引擎（`createSyncEngine`）与写触发调度器、选或实现传输端口
+// （`SyncBackend` / `createGitSyncBackend`）、以及读同步状态要用的远端布局与 manifest 助手。
+// 文件名口径（读/写两个方向的 `isEntryFileNameFor*` 与 `foldFileName`）与 `applyEntryFiles` 的入参类型
+// （`ApplyChange` / `ApplyResult`）在 store 分区、配置子树（`SyncConfig` / `syncConfigErrors`）
+// 在配置分区：一个符号只导一次，分区跟拥有它的模块走。
+export { NonFastForwardError } from "./sync/backend.js";
+export type {
+	RemoteView,
+	SyncBackend,
+	SyncInitResult,
+	SyncPublishChanges,
+	SyncRunOptions,
+	SyncScope,
+} from "./sync/backend.js";
+
+export { createGitSyncBackend, gitAvailable } from "./sync/backend-git.js";
+export type { GitSyncBackendOptions } from "./sync/backend-git.js";
+
+export { conflictSuffix, resolveConflict } from "./sync/conflict.js";
+export type { ConflictInput, ConflictOutcome, ConflictSide } from "./sync/conflict.js";
+
+export { devicePath, loadOrCreateDevice } from "./sync/device.js";
+export type { DeviceIdentity } from "./sync/device.js";
+
+export { diffThreeWay, isEmptyDiff } from "./sync/diff.js";
+export type { SyncConflict, SyncDiff } from "./sync/diff.js";
+
+export { createSyncEngine } from "./sync/engine.js";
+export type { SyncEngine, SyncEngineOptions, SyncRoundResult, SyncStatusReport } from "./sync/engine.js";
+
+export { sha256Hex } from "./sync/hash.js";
+
+export {
+	MANIFEST_VERSION,
+	emptyManifest,
+	manifestMatchesTransport,
+	manifestPath,
+	readManifest,
+	syncTransport,
+	writeManifest,
+} from "./sync/manifest.js";
+export type { SyncManifest, SyncTransport } from "./sync/manifest.js";
+
+// 布局的单一来源：适配层渲染「这条记忆在远端哪里」一律调这几个，不要就地拼 `git/` 字面量；
+// 本地状态（`.sync` 目录与根锁文件）同理 —— `syncLockPath` 必须与引擎用的是同一条派生，
+// 否则「清除遗弃根锁」删的是一个没人用的文件。`remotePrefix` 收**身份 key**（在这里派生成项目 key），
+// `remotePrefixFromKey` 收已经派生好的**项目 key**（适配层算 status 时手上往往就是它）；
+// 拿错一个是二次转义，不报错，只是远端多一个谁也不认的目录。
+export {
+	SYNC_DIR_NAME,
+	remoteEntryPath,
+	remotePrefix,
+	remotePrefixFromKey,
+	remoteProjectKey,
+	sameSyncRemote,
+	syncLockPath,
+	syncRootPath,
+} from "./sync/paths.js";
+
+export { scanLocalEntries } from "./sync/scan.js";
+export type { LocalScan } from "./sync/scan.js";
+
+// 调度器是泛型：`T` 是「一轮推送的结果」，引擎那一侧代入 `SyncRoundResult` 就不必在公开边界上转型。
+export { createSyncScheduler } from "./sync/scheduler.js";
+export type { SyncScheduler, SyncSchedulerOptions } from "./sync/scheduler.js";
+
+export type { SyncFileInfo, SyncFileSet } from "./sync/types.js";

package/src/injection.ts

@@ -211,9 +211,7 @@ export async function scanEntries(store: MemoryStore): Promise<EntryManifest[]>
 	const summaries = await store.listEntries();
 	return summaries
 		.map((s) => ({ file: s.file, name: s.name, description: s.description, type: s.type, modified: s.modified }))
-		.sort((a, b) =>
-			a.modified === b.modified ? a.file.localeCompare(b.file) : b.modified.localeCompare(a.modified),
-		)
+		.sort((a, b) => (a.modified === b.modified ? a.file.localeCompare(b.file) : b.modified.localeCompare(a.modified)))
 		.slice(0, SIDE_QUERY_MAX_ENTRIES);
 }
 

package/src/orchestration/conversation.ts

@@ -63,8 +63,7 @@ function clipMiddle(text: string, maxChars: number, alreadyOmitted = 0, markerAt
 	if (label !== "") {
 		body =
 			markerAt >= 0 && text.startsWith(label, markerAt)
-				? text.slice(0, markerAt) +
-					text.slice(markerAt + label.length + (text[markerAt + label.length] === "\n" ? 1 : 0))
+				? text.slice(0, markerAt) + text.slice(markerAt + label.length + (text[markerAt + label.length] === "\n" ? 1 : 0))
 				: removeLastOccurrence(text, label);
 	}
 	// 给标记文本预留位置（按一个六位数省略量估算），避免「裁减之后反而更长」。

package/src/orchestration/dream.ts

@@ -37,4 +37,3 @@ export const dream: MemoryTask<Record<string, never>, string> = {
 		}
 	},
 };
-

package/src/orchestration/extract.ts

@@ -57,4 +57,3 @@ export const extractMemories: MemoryTask<ExtractInput, ExtractResult> = {
 		return { onWrite: input.onWrite };
 	},
 };
-

package/src/orchestration/ports.ts

@@ -98,11 +98,7 @@ export interface ExtractMessage {
 /** 宿主的会话历史：既供 `search scope=sessions`，也供 extract 的对话渲染。 */
 export interface HostTranscriptPort {
 	/** 搜历史会话，返回已格式化好的文本（宿主决定格式与截断）。 */
-	searchSessions(
-		cwd: string,
-		query: string,
-		cfg: { maxSessions: number; maxMatches: number },
-	): Promise<string>;
+	searchSessions(cwd: string, query: string, cfg: { maxSessions: number; maxMatches: number }): Promise<string>;
 	/**
 	 * 把宿主的原始消息序列转成中立的 `ExtractMessage`。
 	 * 形状不认识的消息按「尽量保留文本」处理；**未知 role 绝不当作 user**（user 文本不截断，

package/src/orchestration/prompts.ts

@@ -112,4 +112,3 @@ export function buildExtractTask(
 		conversation,
 	].join("\n");
 }
-

package/src/orchestration/surfacing.ts

@@ -65,4 +65,3 @@ export const autoSurfacing: MemoryTask<SurfacingInput, SurfacingResult> = {
 		return { files: [], content: "" };
 	},
 };
-

package/src/orchestration/task.ts

@@ -1,11 +1,6 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
-import {
-	requiredModel,
-	type MemoryConfig,
-	type ModelTask,
-	type SessionPersistenceConfig,
-} from "../config.js";
+import { requiredModel, type MemoryConfig, type ModelTask, type SessionPersistenceConfig } from "../config.js";
 import { BACKUP_DIR, type MemoryStore } from "../store/memory-store.js";
 import { createSnapshot } from "../store/snapshot.js";
 import { isReservedWindowsName } from "../store/windows-names.js";
@@ -62,10 +57,7 @@ export interface RequestHost {
 export type MemoryToolOnWrite = (info: { action: MemoryAction; name?: string }) => void;
 
 /** `notCompleted` 收的 `why`：core 自己的判定，或端口给的非 completed 结果。 */
-export type Incomplete =
-	| { status: "no-input" }
-	| { status: "lock-busy" }
-	| IncompleteOutcome;
+export type Incomplete = { status: "no-input" } | { status: "lock-busy" } | IncompleteOutcome;
 
 export interface MemoryTask<I, R> {
 	readonly id: ModelTask;

package/src/store/filename.ts

@@ -12,6 +12,77 @@ const STEM_MAX_BYTES = 100;
 
 export const ENTRY_EXT = ".md";
 
+/**
+ * 索引文件的文件名。定义在这里而不是 `memory-store.ts`：两个方向的文件名谓词都要排除它，
+ * 而从 store 那边 import 会造成循环依赖。`memory-store.ts` 的公开出口 `INDEX_FILE` 是它的别名，
+ * 名字/类型/值都不变。
+ */
+export const ENTRY_INDEX_FILE = "MEMORY.md";
+
+/**
+ * 把文件名折叠成本地文件系统眼里的「同一个名字」：先 NFC 归一，再在 win32 / darwin 上去掉大小写。
+ *
+ * 为什么需要：`Foo.md` 与 `foo.md` 在 Linux 上是两条合法记忆，在 APFS / NTFS 上是同一个 inode ——
+ * 按名逐字直写会静默写穿一条（后写的那份盖掉先写的那份，两边都不报错）。NFC 归一同理：
+ * APFS / HFS+ 对 NFD 与 NFC 的两个名字做同一次查找。
+ *
+ * **跟平台**是它的核心语义，不是可选修饰：Linux 上把大小写也折叠掉，会让两条本来合法的
+ * 记忆被当成碰撞而丢掉一条。折叠只用于「是否同一个名字」的比较，绝不用于生成落盘的文件名。
+ */
+export function foldFileName(name: string, platform: NodeJS.Platform = process.platform): string {
+	const normalized = name.normalize("NFC");
+	return platform === "win32" || platform === "darwin" ? normalized.toLowerCase() : normalized;
+}
+
+/**
+ * 两个方向共用的**形状**判据：单层（不含路径分隔符）、`.md` 结尾、不是索引文件本身、
+ * 不以 `.` 开头（`.lock`、`.backups`、以及用户自己藏的临时文件都不是记忆）。
+ *
+ * 它刻意不导出：外面只该看见两个带方向的谓词，一个没有方向的「是不是条目名」正是
+ * 曾经让读口径与写口径互相串味的那个形状（见下）。
+ */
+function isEntryFileNameShape(name: string): boolean {
+	if (!name.endsWith(ENTRY_EXT)) return false;
+	if (name === ENTRY_INDEX_FILE) return false;
+	if (name.startsWith(".")) return false;
+	if (name.includes("/") || name.includes("\\")) return false;
+	return true;
+}
+
+/**
+ * **读方向**：盘上（或索引里）已有的这个名字，算不算一条看得见的记忆。
+ *
+ * 消费者：`MemoryStore.#entryFiles()` 与同步的本地扫描 —— 两处必须共用这一份，口径一旦漂移
+ * 就会出现「store 看得到、同步看不到」（或反过来）的记忆，那是静默丢记忆。
+ *
+ * 保留设备名**只在 win32 上**剔除：按名打开 `con.md` 在 win32 上会命中控制台（`readFile` 阻塞而
+ * 不是返回内容），把它从清单里剔除的最坏表现是「该条记忆在本机不可见」；而在 Linux / macOS 上
+ * `con.md` 是一个普通文件、一条**合法**记忆，全平台剔除等于把它从 `listEntries()` 里静默抹掉。
+ *
+ * **绝不用它判「能不能写」**：写路径要的是全平台口径，见 `isEntryFileNameForWrite`。
+ */
+export function isEntryFileNameForRead(name: string, platform: NodeJS.Platform = process.platform): boolean {
+	if (!isEntryFileNameShape(name)) return false;
+	return platform !== "win32" || !isReservedWindowsName(name);
+}
+
+/**
+ * **写方向**：这个名字能不能被**写下去**（本地落盘，或发布到远端让另一台设备落盘）。
+ *
+ * 口径恒等于 win32（最严的那一个），**没有 platform 参数** —— 这不是疏忽而是它存在的全部理由：
+ * 写下去的文件名会成为跨设备的数据，只要有任何一台设备读不出来，它就是一个黑洞。在 Linux 上
+ * 写 `con.md` 完全合法，可它一旦同步到 Windows 那台机器就再也打不开（按名打开命中控制台），
+ * 而同步轮会在落盘前整批抛错 —— 一个名字让两台设备永久不同步。
+ *
+ * 消费者：`MemoryStore.applyEntryFiles` 的整批路径断言，以及**一切从网络进来的名字**
+ *（引擎在把远端清单交给差集之前先过它）。凡是「这个名字的归宿是某个文件系统」的判断都用它；
+ * 用读方向去判远端名字，就是把「本机读得懂」当成「每台设备都写得下」，那正是整批抛错的成因。
+ */
+export function isEntryFileNameForWrite(name: string): boolean {
+	if (!isEntryFileNameShape(name)) return false;
+	return !isReservedWindowsName(name);
+}
+
 function shortHash(input: string): string {
 	return createHash("sha256").update(input, "utf8").digest("hex").slice(0, 8);
 }

package/src/store/fs-lock.ts

@@ -41,9 +41,7 @@ export class MemoryLockedError extends Error {
 		/** 记录指向一个已死的本机进程，或本身无法解释 —— 没有任何人会释放它，只能人工清除。 */
 		readonly abandoned: boolean,
 	) {
-		const described = holder
-			? `${holder.op} (pid ${holder.pid}, started ${holder.startedAt})`
-			: "an unreadable record";
+		const described = holder ? `${holder.op} (pid ${holder.pid}, started ${holder.startedAt})` : "an unreadable record";
 		super(
 			abandoned
 				? `Memory lock at ${lockPath} is abandoned by ${described} — delete the file to clear it`
@@ -134,9 +132,7 @@ export async function readLockStatus(
 	return state.kind === "empty" ? { kind: "unreadable" } : state;
 }
 
-type AcquireOutcome =
-	| { acquired: true }
-	| { acquired: false; holder: LockInfo | null; abandoned: boolean };
+type AcquireOutcome = { acquired: true } | { acquired: false; holder: LockInfo | null; abandoned: boolean };
 
 /**
  * 尝试一次获取。路径为空时不当作失败 —— 那是「刚好被释放」，直接再试一次 `open(wx)`（CAS 会自然地