@ectplsm/relic 0.3.2 → 0.4.0

package/dist/core/ports/mikoshi.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Shared sub-schemas
+// ---------------------------------------------------------------------------
+export const PersonaFileSchema = z.object({
+    fileType: z.enum(["SOUL", "IDENTITY", "ENGRAM_JSON"]),
+    filename: z.string(),
+});
+export const MemorySummarySchema = z.object({
+    hasMemory: z.boolean(),
+    hasUserFile: z.boolean().optional(),
+    hasMemoryIndex: z.boolean().optional(),
+    memoryEntryCount: z.number().optional(),
+    latestMemoryDate: z.string().nullable().optional(),
+    memoryUpdatedAt: z.string().nullable().optional(),
+});
+// ---------------------------------------------------------------------------
+// Engram list / detail
+// ---------------------------------------------------------------------------
+export const MikoshiEngramSchema = z.object({
+    id: z.string(),
+    sourceEngramId: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    visibility: z.enum(["PRIVATE", "UNLISTED", "PUBLIC"]),
+    tags: z.array(z.string()),
+    avatarUrl: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    personaFiles: z.array(PersonaFileSchema),
+    memory: MemorySummarySchema.optional(),
+});
+// ---------------------------------------------------------------------------
+// Engram detail (with persona content)
+// ---------------------------------------------------------------------------
+export const PersonaFileWithContentSchema = z.object({
+    fileType: z.enum(["SOUL", "IDENTITY", "ENGRAM_JSON"]),
+    filename: z.string(),
+    content: z.string(),
+});
+export const MikoshiEngramDetailSchema = z.object({
+    id: z.string(),
+    sourceEngramId: z.string(),
+    name: z.string(),
+    description: z.string().nullable(),
+    visibility: z.enum(["PRIVATE", "UNLISTED", "PUBLIC"]),
+    tags: z.array(z.string()),
+    avatarUrl: z.string().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    personaFiles: z.array(PersonaFileWithContentSchema),
+    memory: MemorySummarySchema.optional(),
+});
+// ---------------------------------------------------------------------------
+// Create engram
+// ---------------------------------------------------------------------------
+export const CreateEngramInputSchema = z.object({
+    name: z.string(),
+    sourceEngramId: z.string(),
+    description: z.string().optional(),
+    visibility: z.enum(["PRIVATE", "UNLISTED", "PUBLIC"]).optional(),
+    tags: z.array(z.string()).optional(),
+    soul: z.string(),
+    identity: z.string(),
+});
+export const CreateEngramResponseSchema = z.object({
+    id: z.string(),
+    sourceEngramId: z.string(),
+    name: z.string(),
+    visibility: z.string(),
+    url: z.string(),
+});
+// ---------------------------------------------------------------------------
+// Update persona
+// ---------------------------------------------------------------------------
+export const UpdatePersonaInputSchema = z.object({
+    soul: z.string(),
+    identity: z.string(),
+    expectedRemotePersonaHash: z.string(),
+});
+export const UpdatePersonaResponseSchema = z.object({
+    engramId: z.string(),
+    persona: z.object({
+        hash: z.string(),
+        updatedAt: z.string(),
+    }),
+});
+// ---------------------------------------------------------------------------
+// Sync status
+// ---------------------------------------------------------------------------
+export const PersonaSyncTokenSchema = z.object({
+    hash: z.string(),
+    updatedAt: z.string(),
+});
+export const PersonaSyncStatusSchema = z.object({
+    exists: z.boolean(),
+    token: PersonaSyncTokenSchema.nullable(),
+    files: z.object({
+        hasSoul: z.boolean(),
+        hasIdentity: z.boolean(),
+    }),
+});
+export const MemorySyncTokenSchema = z.object({
+    memoryContentHash: z.string(),
+    bundleHash: z.string(),
+    version: z.number(),
+    updatedAt: z.string(),
+});
+export const MemorySyncSummarySchema = z.object({
+    hasUserFile: z.boolean(),
+    hasMemoryIndex: z.boolean(),
+    memoryEntryCount: z.number(),
+    latestMemoryDate: z.string().nullable(),
+});
+export const MemorySyncStatusSchema = z.object({
+    exists: z.boolean(),
+    token: MemorySyncTokenSchema.nullable(),
+    summary: MemorySyncSummarySchema.nullable(),
+});
+export const SyncStatusResponseSchema = z.object({
+    engramId: z.string(),
+    persona: PersonaSyncStatusSchema,
+    memory: MemorySyncStatusSchema,
+});
+// ---------------------------------------------------------------------------
+// Memory upload
+// ---------------------------------------------------------------------------
+export const ScryptParamsSchema = z.object({
+    N: z.number(),
+    r: z.number(),
+    p: z.number(),
+    dkLen: z.number(),
+});
+export const MemoryManifestSchema = z.object({
+    payloadKind: z.literal("memory"),
+    bundleVersion: z.number(),
+    hasUserFile: z.boolean(),
+    hasMemoryIndex: z.boolean(),
+    memoryEntryCount: z.number(),
+    latestMemoryDate: z.string().nullable(),
+});
+export const UploadMemoryInputSchema = z.object({
+    ciphertext: z.string(),
+    cipherAlgorithm: z.literal("AES-256-GCM"),
+    cipherNonce: z.string(),
+    wrappedBundleKey: z.string(),
+    wrapAlgorithm: z.literal("AES-256-GCM"),
+    kdfAlgorithm: z.literal("scrypt"),
+    kdfSalt: z.string(),
+    kdfParams: ScryptParamsSchema,
+    manifest: MemoryManifestSchema,
+    expectedRemoteMemoryContentHash: z.string().nullable(),
+    memoryContentHash: z.string(),
+    bundleHash: z.string(),
+});
+export const UploadMemoryResponseSchema = z.object({
+    engramId: z.string(),
+    version: z.number(),
+    memoryContentHash: z.string(),
+    bundleHash: z.string(),
+    updatedAt: z.string(),
+});
+// ---------------------------------------------------------------------------
+// Memory download
+// ---------------------------------------------------------------------------
+export const DownloadMemoryResponseSchema = z.discriminatedUnion("hasMemory", [
+    z.object({
+        engramId: z.string(),
+        hasMemory: z.literal(true),
+        version: z.number(),
+        ciphertext: z.string(),
+        cipherAlgorithm: z.literal("AES-256-GCM"),
+        cipherNonce: z.string(),
+        wrappedBundleKey: z.string(),
+        wrapAlgorithm: z.literal("AES-256-GCM"),
+        kdfAlgorithm: z.literal("scrypt"),
+        kdfSalt: z.string(),
+        kdfParams: ScryptParamsSchema,
+        manifest: MemoryManifestSchema,
+        memoryContentHash: z.string(),
+        bundleHash: z.string(),
+        createdAt: z.string(),
+        updatedAt: z.string(),
+    }),
+    z.object({
+        engramId: z.string(),
+        hasMemory: z.literal(false),
+    }),
+]);
+// ---------------------------------------------------------------------------
+// Error types
+// ---------------------------------------------------------------------------
+export class MikoshiApiError extends Error {
+    status;
+    code;
+    body;
+    constructor(status, code, message, body) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.body = body;
+        this.name = "MikoshiApiError";
+    }
+    get isUnauthorized() { return this.status === 401; }
+    get isForbidden() { return this.status === 403; }
+    get isNotFound() { return this.status === 404; }
+    get isConflict() { return this.status === 409; }
+    get isRateLimited() { return this.status === 429; }
+}

package/dist/core/sync/crypto.d.ts

@@ -0,0 +1,55 @@
+export interface KdfParams {
+    N: number;
+    r: number;
+    p: number;
+    dkLen: number;
+}
+export interface MemoryManifest {
+    payloadKind: "memory";
+    bundleVersion: 1;
+    hasUserFile: boolean;
+    hasMemoryIndex: boolean;
+    memoryEntryCount: number;
+    latestMemoryDate: string | null;
+}
+/** 暗号化結果 — Mikoshi upload payload にそのまま乗せられる形 */
+export interface EncryptedMemoryBundle {
+    ciphertext: string;
+    cipherAlgorithm: "AES-256-GCM";
+    cipherNonce: string;
+    wrappedBundleKey: string;
+    wrapAlgorithm: "AES-256-GCM";
+    kdfAlgorithm: "scrypt";
+    kdfSalt: string;
+    kdfParams: KdfParams;
+    manifest: MemoryManifest;
+    bundleHash: string;
+}
+/** 復号結果 — ファイルパス→コンテンツの Map */
+export type DecryptedMemoryFiles = Record<string, string>;
+/**
+ * Memory ファイル群を暗号化して EncryptedMemoryBundle を返す。
+ *
+ * @param files  パス → コンテンツ (例: { "USER.md": "...", "memory/2026-04-03.md": "..." })
+ * @param passphrase  ユーザーのパスフレーズ
+ */
+export declare function encryptMemoryBundle(files: Record<string, string>, passphrase: string): EncryptedMemoryBundle;
+/**
+ * EncryptedMemoryBundle を復号して memory ファイル群を返す。
+ *
+ * @param bundle  Mikoshi からダウンロードした暗号化バンドル
+ * @param passphrase  ユーザーのパスフレーズ
+ * @throws パスフレーズ不一致やデータ破損時に Error
+ */
+export declare function decryptMemoryBundle(bundle: {
+    ciphertext: string;
+    cipherNonce: string;
+    wrappedBundleKey: string;
+    kdfSalt: string;
+    kdfParams: KdfParams;
+}, passphrase: string): DecryptedMemoryFiles;
+/**
+ * TTY から非表示入力でパスフレーズを読む。
+ * 入力中は文字が画面に出ない。
+ */
+export declare function readPassphrase(prompt: string): Promise<string>;

package/dist/core/sync/crypto.js

@@ -0,0 +1,189 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync, } from "node:crypto";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const CIPHER_ALGORITHM = "aes-256-gcm";
+const DEFAULT_KDF_PARAMS = {
+    N: 16384,
+    r: 8,
+    p: 1,
+    dkLen: 32,
+};
+const SALT_BYTES = 16;
+const DEK_BYTES = 32;
+const NONCE_BYTES = 12; // AES-256-GCM standard IV
+// ---------------------------------------------------------------------------
+// Encrypt
+// ---------------------------------------------------------------------------
+/**
+ * Memory ファイル群を暗号化して EncryptedMemoryBundle を返す。
+ *
+ * @param files  パス → コンテンツ (例: { "USER.md": "...", "memory/2026-04-03.md": "..." })
+ * @param passphrase  ユーザーのパスフレーズ
+ */
+export function encryptMemoryBundle(files, passphrase) {
+    // 1. scrypt: passphrase → KEK
+    const salt = randomBytes(SALT_BYTES);
+    const kek = deriveKek(passphrase, salt, DEFAULT_KDF_PARAMS);
+    // 2. Random DEK
+    const dek = randomBytes(DEK_BYTES);
+    // 3. Bundle: files → JSON → UTF-8 bytes
+    const plaintext = Buffer.from(JSON.stringify(files), "utf-8");
+    // 4. DEK + AES-256-GCM → ciphertext
+    const dataNonce = randomBytes(NONCE_BYTES);
+    const { encrypted: ciphertext, authTag: dataTag } = aesGcmEncrypt(dek, dataNonce, plaintext);
+    // GCM の authTag を ciphertext 末尾に結合 (16 bytes)
+    const ciphertextWithTag = Buffer.concat([ciphertext, dataTag]);
+    // 5. KEK + AES-256-GCM → wrappedBundleKey (nonce(12) + encrypted + authTag(16))
+    const wrapNonce = randomBytes(NONCE_BYTES);
+    const { encrypted: wrappedKey, authTag: wrapTag } = aesGcmEncrypt(kek, wrapNonce, dek);
+    const wrappedBundleKey = Buffer.concat([wrapNonce, wrappedKey, wrapTag]);
+    // 6. Manifest
+    const manifest = buildManifest(files);
+    // 7. bundleHash = SHA-256(ciphertext with tag)
+    const bundleHash = `sha256:${createHash("sha256").update(ciphertextWithTag).digest("hex")}`;
+    return {
+        ciphertext: ciphertextWithTag.toString("base64"),
+        cipherAlgorithm: "AES-256-GCM",
+        cipherNonce: dataNonce.toString("base64"),
+        wrappedBundleKey: wrappedBundleKey.toString("base64"),
+        wrapAlgorithm: "AES-256-GCM",
+        kdfAlgorithm: "scrypt",
+        kdfSalt: salt.toString("base64"),
+        kdfParams: { ...DEFAULT_KDF_PARAMS },
+        manifest,
+        bundleHash,
+    };
+}
+// ---------------------------------------------------------------------------
+// Decrypt
+// ---------------------------------------------------------------------------
+/**
+ * EncryptedMemoryBundle を復号して memory ファイル群を返す。
+ *
+ * @param bundle  Mikoshi からダウンロードした暗号化バンドル
+ * @param passphrase  ユーザーのパスフレーズ
+ * @throws パスフレーズ不一致やデータ破損時に Error
+ */
+export function decryptMemoryBundle(bundle, passphrase) {
+    // 1. scrypt: passphrase → KEK
+    const salt = Buffer.from(bundle.kdfSalt, "base64");
+    const kek = deriveKek(passphrase, salt, bundle.kdfParams);
+    // 2. KEK → DEK を復号
+    const wrappedBuf = Buffer.from(bundle.wrappedBundleKey, "base64");
+    const dek = aesGcmDecrypt(kek, wrappedBuf);
+    // 3. DEK → plaintext を復号
+    const nonce = Buffer.from(bundle.cipherNonce, "base64");
+    const ciphertextBuf = Buffer.from(bundle.ciphertext, "base64");
+    const plaintext = aesGcmDecryptWithNonce(dek, nonce, ciphertextBuf);
+    // 4. JSON parse
+    return JSON.parse(plaintext.toString("utf-8"));
+}
+// ---------------------------------------------------------------------------
+// Passphrase input
+// ---------------------------------------------------------------------------
+/**
+ * TTY から非表示入力でパスフレーズを読む。
+ * 入力中は文字が画面に出ない。
+ */
+export function readPassphrase(prompt) {
+    return new Promise((resolve, reject) => {
+        if (!process.stdin.isTTY) {
+            reject(new Error("Cannot read passphrase: stdin is not a TTY"));
+            return;
+        }
+        process.stdout.write(prompt);
+        const raw = process.stdin.setRawMode?.(true);
+        if (!raw) {
+            reject(new Error("Cannot enable raw mode on stdin"));
+            return;
+        }
+        process.stdin.resume();
+        process.stdin.setEncoding("utf-8");
+        let input = "";
+        const onData = (ch) => {
+            const c = ch.toString();
+            if (c === "\n" || c === "\r" || c === "\u0004") {
+                // Enter or Ctrl+D
+                process.stdin.setRawMode?.(false);
+                process.stdin.pause();
+                process.stdin.removeListener("data", onData);
+                process.stdout.write("\n");
+                resolve(input);
+            }
+            else if (c === "\u0003") {
+                // Ctrl+C
+                process.stdin.setRawMode?.(false);
+                process.stdin.pause();
+                process.stdin.removeListener("data", onData);
+                process.stdout.write("\n");
+                reject(new Error("Cancelled"));
+            }
+            else if (c === "\u007f" || c === "\b") {
+                // Backspace
+                if (input.length > 0) {
+                    input = input.slice(0, -1);
+                }
+            }
+            else {
+                input += c;
+            }
+        };
+        process.stdin.on("data", onData);
+    });
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function deriveKek(passphrase, salt, params) {
+    return scryptSync(passphrase, salt, params.dkLen, {
+        N: params.N,
+        r: params.r,
+        p: params.p,
+    });
+}
+function aesGcmEncrypt(key, nonce, plaintext) {
+    const cipher = createCipheriv(CIPHER_ALGORITHM, key, nonce);
+    const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    return { encrypted, authTag };
+}
+/**
+ * wrappedBundleKey 復号用 — nonce は先頭 12 bytes に含まれている想定ではなく、
+ * wrappedKey = encrypted(32) + authTag(16) = 48 bytes の固定構造。
+ * nonce は wrap 時にランダム生成したものだが、upload payload には cipherNonce しかない。
+ *
+ * → wrappedBundleKey は nonce を自己完結させる必要がある。
+ *   構造を nonce(12) + encrypted + authTag(16) に変更する。
+ */
+function aesGcmDecrypt(key, data) {
+    // data = nonce(12) + encrypted + authTag(16)
+    const nonce = data.subarray(0, NONCE_BYTES);
+    const authTag = data.subarray(data.length - 16);
+    const encrypted = data.subarray(NONCE_BYTES, data.length - 16);
+    const decipher = createDecipheriv(CIPHER_ALGORITHM, key, nonce);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]);
+}
+function aesGcmDecryptWithNonce(key, nonce, data) {
+    // data = encrypted + authTag(16)
+    const authTag = data.subarray(data.length - 16);
+    const encrypted = data.subarray(0, data.length - 16);
+    const decipher = createDecipheriv(CIPHER_ALGORITHM, key, nonce);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([decipher.update(encrypted), decipher.final()]);
+}
+function buildManifest(files) {
+    const memoryEntryPaths = Object.keys(files).filter((p) => p.startsWith("memory/"));
+    const dates = memoryEntryPaths
+        .map((p) => p.replace("memory/", "").replace(".md", ""))
+        .sort();
+    return {
+        payloadKind: "memory",
+        bundleVersion: 1,
+        hasUserFile: "USER.md" in files,
+        hasMemoryIndex: "MEMORY.md" in files,
+        memoryEntryCount: memoryEntryPaths.length,
+        latestMemoryDate: dates.length > 0 ? dates[dates.length - 1] : null,
+    };
+}

package/dist/core/sync/memory-hash.d.ts

@@ -0,0 +1,35 @@
+import type { EngramFiles } from "../entities/engram.js";
+/**
+ * Memory ファイルエントリ
+ * path はソート用の相対パス ("USER.md", "MEMORY.md", "memory/2026-04-03.md" など)
+ */
+export interface MemoryFileEntry {
+    path: string;
+    content: string;
+}
+/**
+ * Memory content hash canonicalization — mikoshi-sync.md 準拠
+ *
+ * 正規化ルール:
+ *  - UTF-8 BOM 除去
+ *  - 改行を \n に統一
+ *  - 末尾 \n は除去しない（persona と異な���）
+ *
+ * Canonical payload:
+ *  header \n ( path \n byteLen \n content \n )*
+ *  ファイルはパス昇順でソート
+ *
+ * 出力: "sha256:<64 lowercase hex>"
+ * 対象ファイルが0件なら null
+ */
+export declare function computeMemoryContentHash(files: MemoryFileEntry[]): string | null;
+/**
+ * EngramFiles から memory 系ファイルを MemoryFileEntry[] に変換。
+ * 対象: USER.md, MEMORY.md, memory/*.md
+ */
+export declare function collectMemoryFiles(files: EngramFiles): MemoryFileEntry[];
+/**
+ * MemoryFileEntry[] を { "USER.md": "...", "memory/2026-04-03.md": "..." } に変換。
+ * 暗号化バンドルの入力用。
+ */
+export declare function memoryFilesToRecord(entries: MemoryFileEntry[]): Record<string, string>;

package/dist/core/sync/memory-hash.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { normalizeText } from "./normalize.js";
+const HEADER = "mikoshi.memory.v1";
+/**
+ * Memory content hash canonicalization — mikoshi-sync.md 準拠
+ *
+ * 正規化ルール:
+ *  - UTF-8 BOM 除去
+ *  - 改行を \n に統一
+ *  - 末尾 \n は除去しない（persona と異な���）
+ *
+ * Canonical payload:
+ *  header \n ( path \n byteLen \n content \n )*
+ *  ファイルはパス昇順でソート
+ *
+ * 出力: "sha256:<64 lowercase hex>"
+ * 対象ファイルが0件なら null
+ */
+export function computeMemoryContentHash(files) {
+    if (files.length === 0)
+        return null;
+    // パス昇順ソート
+    const sorted = [...files].sort((a, b) => a.path.localeCompare(b.path));
+    const parts = [HEADER];
+    for (const file of sorted) {
+        const norm = normalizeText(file.content);
+        const byteLen = Buffer.byteLength(norm, "utf-8");
+        parts.push(file.path, String(byteLen), norm);
+    }
+    const payload = parts.join("\n");
+    const hex = createHash("sha256").update(payload, "utf-8").digest("hex");
+    return `sha256:${hex}`;
+}
+/**
+ * EngramFiles から memory 系ファイルを MemoryFileEntry[] に変換。
+ * 対象: USER.md, MEMORY.md, memory/*.md
+ */
+export function collectMemoryFiles(files) {
+    const entries = [];
+    if (files.user)
+        entries.push({ path: "USER.md", content: files.user });
+    if (files.memory)
+        entries.push({ path: "MEMORY.md", content: files.memory });
+    if (files.memoryEntries) {
+        for (const [date, content] of Object.entries(files.memoryEntries)) {
+            entries.push({ path: `memory/${date}.md`, content });
+        }
+    }
+    return entries;
+}
+/**
+ * MemoryFileEntry[] を { "USER.md": "...", "memory/2026-04-03.md": "..." } に変換。
+ * 暗号化バンドルの入力用。
+ */
+export function memoryFilesToRecord(entries) {
+    const record = {};
+    for (const e of entries) {
+        record[e.path] = e.content;
+    }
+    return record;
+}

package/dist/core/sync/memory-merge.d.ts

@@ -0,0 +1,13 @@
+import type { EngramFiles } from "../entities/engram.js";
+export interface MemoryRecordDiff {
+    added: string[];
+    changed: string[];
+    removed: string[];
+}
+export interface MergeMemoryRecordsResult {
+    merged: Record<string, string>;
+    changedPaths: string[];
+}
+export declare function computeMemoryRecordDiff(local: Record<string, string>, remote: Record<string, string>): MemoryRecordDiff;
+export declare function mergeMemoryRecords(local: Record<string, string>, remote: Record<string, string>): MergeMemoryRecordsResult;
+export declare function applyMemoryRecordToFiles(files: EngramFiles, record: Record<string, string>): EngramFiles;

package/dist/core/sync/memory-merge.js

@@ -0,0 +1,84 @@
+import { normalizeText } from "./normalize.js";
+export function computeMemoryRecordDiff(local, remote) {
+    const allPaths = new Set([...Object.keys(local), ...Object.keys(remote)]);
+    const added = [];
+    const changed = [];
+    const removed = [];
+    for (const path of [...allPaths].sort()) {
+        const inLocal = path in local;
+        const inRemote = path in remote;
+        if (inRemote && !inLocal) {
+            added.push(path);
+        }
+        else if (inLocal && !inRemote) {
+            removed.push(path);
+        }
+        else if (inLocal && inRemote && local[path] !== remote[path]) {
+            changed.push(path);
+        }
+    }
+    return { added, changed, removed };
+}
+export function mergeMemoryRecords(local, remote) {
+    const allPaths = new Set([...Object.keys(local), ...Object.keys(remote)]);
+    const merged = {};
+    const changedPaths = [];
+    for (const path of [...allPaths].sort()) {
+        const localContent = local[path];
+        const remoteContent = remote[path];
+        const mergedContent = mergeTextMonotonic(localContent, remoteContent);
+        if (mergedContent === undefined)
+            continue;
+        merged[path] = mergedContent;
+        if (mergedContent !== localContent || mergedContent !== remoteContent) {
+            changedPaths.push(path);
+        }
+    }
+    return { merged, changedPaths };
+}
+export function applyMemoryRecordToFiles(files, record) {
+    const updatedFiles = {
+        ...files,
+        user: record["USER.md"] ?? undefined,
+        memory: record["MEMORY.md"] ?? undefined,
+    };
+    const memoryEntries = {};
+    for (const [path, content] of Object.entries(record)) {
+        if (path.startsWith("memory/") && path.endsWith(".md")) {
+            const date = path.replace("memory/", "").replace(".md", "");
+            memoryEntries[date] = content;
+        }
+    }
+    updatedFiles.memoryEntries = Object.keys(memoryEntries).length > 0 ? memoryEntries : undefined;
+    return updatedFiles;
+}
+function mergeTextMonotonic(local, remote) {
+    if (local === undefined)
+        return remote;
+    if (remote === undefined)
+        return local;
+    if (local === remote)
+        return local;
+    const blocks = [
+        ...splitBlocks(local),
+        ...splitBlocks(remote),
+    ];
+    const seen = new Set();
+    const mergedBlocks = [];
+    for (const block of blocks) {
+        if (!seen.has(block)) {
+            seen.add(block);
+            mergedBlocks.push(block);
+        }
+    }
+    return mergedBlocks.join("\n\n");
+}
+function splitBlocks(content) {
+    const normalized = normalizeText(content).trim();
+    if (!normalized)
+        return [];
+    return normalized
+        .split(/\n{2,}/)
+        .map((block) => block.trim())
+        .filter((block) => block.length > 0);
+}

package/dist/core/sync/normalize.d.ts

@@ -0,0 +1,10 @@
+/**
+ * テキスト正規化 — mikoshi-sync.md 共通ルール
+ *
+ * - UTF-8 BOM 除去
+ * - 改行を \n に統一
+ * - stripTrailingNewlines: true なら末尾 \n を除去（persona 用）
+ */
+export declare function normalizeText(text: string, opts?: {
+    stripTrailingNewlines?: boolean;
+}): string;

package/dist/core/sync/normalize.js

@@ -0,0 +1,21 @@
+/**
+ * テキスト正規化 — mikoshi-sync.md 共通ルール
+ *
+ * - UTF-8 BOM 除去
+ * - 改行を \n に統一
+ * - stripTrailingNewlines: true なら末尾 \n を除去（persona 用）
+ */
+export function normalizeText(text, opts) {
+    let s = text;
+    // strip leading BOM
+    if (s.charCodeAt(0) === 0xfeff) {
+        s = s.slice(1);
+    }
+    // normalize line endings to \n
+    s = s.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    // strip trailing \n (persona only)
+    if (opts?.stripTrailingNewlines) {
+        s = s.replace(/\n+$/, "");
+    }
+    return s;
+}