@ectplsm/relic 0.4.0 → 0.5.0

package/README.md

@@ -112,7 +112,7 @@ As you use a Construct, conversation logs are automatically saved to `archive.md
 
 > **"Organize my memories"**
 
-The Construct will review recent conversations, extract key facts and decisions into `memory/*.md`, promote important long-term insights to `MEMORY.md`, and update your preferences in `USER.md`. These distilled memories are then loaded into future sessions automatically.
+The Construct will review recent conversations, group them by the actual dates recorded in `archive.md`, extract key facts and decisions into the matching `memory/*.md` files, promote important long-term insights to `MEMORY.md`, and update your preferences in `USER.md`. These distilled memories are then loaded into future sessions automatically.
 
 ### 5. Learn More
 
@@ -184,9 +184,9 @@ For Engram creation, the smoothest path is to use your LLM with the `relic_engra
 
 For LLM-assisted creation, persona authoring, template examples, and deletion rules, see [docs/engram-guide.md](docs/engram-guide.md).
 
-## Cloud Storage and Sharing
+## Cloud Storage and Sharing (Mikoshi)
 
-Relic can push plaintext persona files and encrypted memory files to [Mikoshi](https://mikoshi.ectplsm.com), so you can keep Engrams in the cloud and move them across machines without turning Mikoshi into your authoring source of truth.
+Relic can push plaintext persona files and (end-to-end) encrypted memory files to [Mikoshi](https://mikoshi.ectplsm.com), so you can keep Engrams in the cloud and move them across machines without turning Mikoshi into your authoring source of truth.
 
 For setup, API key configuration, persona push/pull, encrypted memory sync, and the recommended command flow, see [docs/mikoshi.md](docs/mikoshi.md).
 

package/dist/core/usecases/archive-cursor-update.d.ts

@@ -16,6 +16,12 @@ export declare class ArchiveCursorUpdate {
     execute(engramId: string, count: number): Promise<ArchiveCursorUpdateResult>;
     private readCursor;
 }
+export declare class ArchiveCursorAdvanceOverflowError extends Error {
+    readonly id: string;
+    readonly requestedCount: number;
+    readonly availablePending: number;
+    constructor(id: string, requestedCount: number, availablePending: number);
+}
 export declare class ArchiveCursorUpdateEngramNotFoundError extends Error {
     constructor(id: string);
 }

package/dist/core/usecases/archive-cursor-update.js

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
+import { ArchivePending } from "./archive-pending.js";
 /**
  * ArchiveCursorUpdate — archive.cursor を指定件数分だけ進める
  *
@@ -19,6 +20,11 @@ export class ArchiveCursorUpdate {
         }
         const cursorPath = join(engramDir, "archive.cursor");
         const previousCursor = await this.readCursor(cursorPath);
+        const archivePending = new ArchivePending(this.engramsPath);
+        const pending = await archivePending.execute(engramId, Number.MAX_SAFE_INTEGER);
+        if (count > pending.entries.length) {
+            throw new ArchiveCursorAdvanceOverflowError(engramId, count, pending.entries.length);
+        }
         const newCursor = previousCursor + count;
         await writeFile(cursorPath, String(newCursor), "utf-8");
         return { previousCursor, newCursor };
@@ -36,6 +42,18 @@ export class ArchiveCursorUpdate {
         }
     }
 }
+export class ArchiveCursorAdvanceOverflowError extends Error {
+    id;
+    requestedCount;
+    availablePending;
+    constructor(id, requestedCount, availablePending) {
+        super(`Engram "${id}" cursor advance overflow (${requestedCount} > ${availablePending}). Refusing to move archive.cursor.`);
+        this.id = id;
+        this.requestedCount = requestedCount;
+        this.availablePending = availablePending;
+        this.name = "ArchiveCursorAdvanceOverflowError";
+    }
+}
 export class ArchiveCursorUpdateEngramNotFoundError extends Error {
     constructor(id) {
         super(`Engram "${id}" archive not found`);

package/dist/core/usecases/archive-pending.d.ts

@@ -1,6 +1,16 @@
+export interface ArchivePendingEntry {
+    /** archive.md 先頭行から抽出した日付 */
+    date: string | null;
+    /** archive.md 先頭行の summary 部分 */
+    summary: string | null;
+    /** エントリ全文 */
+    raw: string;
+    /** 先頭行を除いた本文 */
+    body: string;
+}
 export interface ArchivePendingResult {
     /** 未蒸留エントリ（cursor以降） */
-    entries: string[];
+    entries: ArchivePendingEntry[];
     /** 現在のcursor位置 */
     cursor: number;
     /** archive内の総エントリ数 */
@@ -8,6 +18,12 @@ export interface ArchivePendingResult {
     /** 今回返さなかった残りの未蒸留エントリ数 */
     remaining: number;
 }
+export declare class ArchiveCursorCorruptedError extends Error {
+    readonly id: string;
+    readonly cursor: number;
+    readonly total: number;
+    constructor(id: string, cursor: number, total: number);
+}
 /**
  * ArchivePending — archive.md の未蒸留エントリを取得する
  *
@@ -20,6 +36,7 @@ export declare class ArchivePending {
     execute(engramId: string, limit?: number): Promise<ArchivePendingResult>;
     private readCursor;
 }
+export declare function parseArchiveEntry(raw: string): ArchivePendingEntry;
 export declare class ArchivePendingEngramNotFoundError extends Error {
     constructor(id: string);
 }

package/dist/core/usecases/archive-pending.js

@@ -2,7 +2,20 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 const ENTRY_SEPARATOR = /\n---\n/;
-const DEFAULT_LIMIT = 30;
+const DEFAULT_LIMIT = 100;
+const ENTRY_HEADER_PATTERN = /^(\d{4}-\d{2}-\d{2}) \| ?(.*)$/;
+export class ArchiveCursorCorruptedError extends Error {
+    id;
+    cursor;
+    total;
+    constructor(id, cursor, total) {
+        super(`Engram "${id}" archive cursor is invalid (${cursor} > ${total}). Repair archive.cursor before distilling.`);
+        this.id = id;
+        this.cursor = cursor;
+        this.total = total;
+        this.name = "ArchiveCursorCorruptedError";
+    }
+}
 /**
  * ArchivePending — archive.md の未蒸留エントリを取得する
  *
@@ -29,11 +42,14 @@ export class ArchivePending {
             .map((e) => e.trim())
             .filter((e) => e.length > 0);
         const cursor = await this.readCursor(engramDir);
+        if (cursor > allEntries.length) {
+            throw new ArchiveCursorCorruptedError(engramId, cursor, allEntries.length);
+        }
         const pendingEntries = allEntries.slice(cursor);
         const effectiveLimit = limit ?? DEFAULT_LIMIT;
         const returned = pendingEntries.slice(0, effectiveLimit);
         return {
-            entries: returned,
+            entries: returned.map(parseArchiveEntry),
             cursor,
             total: allEntries.length,
             remaining: pendingEntries.length - returned.length,
@@ -53,6 +69,25 @@ export class ArchivePending {
         }
     }
 }
+export function parseArchiveEntry(raw) {
+    const trimmed = raw.trim();
+    const [header = "", ...rest] = trimmed.split("\n");
+    const match = header.match(ENTRY_HEADER_PATTERN);
+    if (!match) {
+        return {
+            date: null,
+            summary: null,
+            raw: trimmed,
+            body: trimmed,
+        };
+    }
+    return {
+        date: match[1],
+        summary: match[2] || null,
+        raw: trimmed,
+        body: rest.join("\n").trim(),
+    };
+}
 export class ArchivePendingEngramNotFoundError extends Error {
     constructor(id) {
         super(`Engram "${id}" archive not found`);

package/dist/core/usecases/index.d.ts

@@ -5,11 +5,11 @@ export { MigrateEngrams, type MigrateEngramsResult, } from "./migrate-engrams.js
 export { RefreshSamples, type RefreshSamplesResult, } from "./refresh-samples.js";
 export { Inject, InjectEngramNotFoundError, InjectClawDirNotFoundError, InjectWorkspaceNotFoundError, type InjectPersonaFileDiff, type InjectPersonaDiffResult, type InjectResult, } from "./inject.js";
 export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedError, type ExtractPersonaFileDiff, type ExtractPersonaDiffResult, type ExtractResult, } from "./extract.js";
-export { MemoryWrite, MemoryWriteEngramNotFoundError, type MemoryWriteResult, } from "./memory-write.js";
+export { MemoryWrite, MemoryWriteEngramNotFoundError, type MemoryWriteBatchItem, type MemoryWriteResult, } from "./memory-write.js";
 export { ClawPull, ClawPullEngramNotFoundError, ClawPullWorkspaceNotFoundError, ClawPullPersonaMissingError, type ClawPullResult, type ClawPullDiff, } from "./claw-pull.js";
 export { Sync, SyncOpenclawDirNotFoundError, type SyncTarget, type SyncResult, type SyncInitialResult, } from "./sync.js";
-export { ArchivePending, ArchivePendingEngramNotFoundError, type ArchivePendingResult, } from "./archive-pending.js";
-export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, type ArchiveCursorUpdateResult, } from "./archive-cursor-update.js";
+export { ArchivePending, ArchiveCursorCorruptedError, ArchivePendingEngramNotFoundError, type ArchivePendingEntry, type ArchivePendingResult, } from "./archive-pending.js";
+export { ArchiveCursorUpdate, ArchiveCursorAdvanceOverflowError, ArchiveCursorUpdateEngramNotFoundError, type ArchiveCursorUpdateResult, } from "./archive-cursor-update.js";
 export { MikoshiStatus, MikoshiStatusEngramNotFoundError, MikoshiStatusCloudNotFoundError, type MikoshiStatusResult, } from "./mikoshi-status.js";
 export { MikoshiPush, MikoshiPushEngramNotFoundError, MikoshiPushPersonaHashError, MikoshiPushPersonaConflictError, type MikoshiPushResult, type MikoshiPushApplyResult, } from "./mikoshi-push.js";
 export { MikoshiDownload, MikoshiDownloadAlreadyExistsError, MikoshiDownloadCloudNotFoundError, MikoshiDownloadPersonaMissingError, type MikoshiDownloadResult, } from "./mikoshi-download.js";

package/dist/core/usecases/index.js

@@ -8,8 +8,8 @@ export { Extract, WorkspaceNotFoundError, WorkspaceEmptyError, AlreadyExtractedE
 export { MemoryWrite, MemoryWriteEngramNotFoundError, } from "./memory-write.js";
 export { ClawPull, ClawPullEngramNotFoundError, ClawPullWorkspaceNotFoundError, ClawPullPersonaMissingError, } from "./claw-pull.js";
 export { Sync, SyncOpenclawDirNotFoundError, } from "./sync.js";
-export { ArchivePending, ArchivePendingEngramNotFoundError, } from "./archive-pending.js";
-export { ArchiveCursorUpdate, ArchiveCursorUpdateEngramNotFoundError, } from "./archive-cursor-update.js";
+export { ArchivePending, ArchiveCursorCorruptedError, ArchivePendingEngramNotFoundError, } from "./archive-pending.js";
+export { ArchiveCursorUpdate, ArchiveCursorAdvanceOverflowError, ArchiveCursorUpdateEngramNotFoundError, } from "./archive-cursor-update.js";
 export { MikoshiStatus, MikoshiStatusEngramNotFoundError, MikoshiStatusCloudNotFoundError, } from "./mikoshi-status.js";
 export { MikoshiPush, MikoshiPushEngramNotFoundError, MikoshiPushPersonaHashError, MikoshiPushPersonaConflictError, } from "./mikoshi-push.js";
 export { MikoshiDownload, MikoshiDownloadAlreadyExistsError, MikoshiDownloadCloudNotFoundError, MikoshiDownloadPersonaMissingError, } from "./mikoshi-download.js";

package/dist/core/usecases/memory-write.d.ts

@@ -4,6 +4,10 @@ export interface MemoryWriteResult {
     appended: boolean;
     path: string;
 }
+export interface MemoryWriteBatchItem {
+    date: string;
+    content: string;
+}
 /**
  * MemoryWrite — Engramのメモリエントリに追記する
  *
@@ -14,6 +18,7 @@ export declare class MemoryWrite {
     private readonly engramsPath;
     constructor(engramsPath: string);
     execute(engramId: string, content: string, date?: string): Promise<MemoryWriteResult>;
+    executeBatch(engramId: string, writes: MemoryWriteBatchItem[]): Promise<MemoryWriteResult[]>;
 }
 export declare class MemoryWriteEngramNotFoundError extends Error {
     constructor(id: string);

package/dist/core/usecases/memory-write.js

@@ -14,29 +14,39 @@ export class MemoryWrite {
     }
     async execute(engramId, content, date) {
         const resolvedDate = date ?? new Date().toISOString().split("T")[0];
+        const [result] = await this.executeBatch(engramId, [
+            { date: resolvedDate, content },
+        ]);
+        return result;
+    }
+    async executeBatch(engramId, writes) {
         const engramDir = join(this.engramsPath, engramId);
         if (!existsSync(engramDir)) {
             throw new MemoryWriteEngramNotFoundError(engramId);
         }
         const memoryDir = join(engramDir, "memory");
         await mkdir(memoryDir, { recursive: true });
-        const filePath = join(memoryDir, `${resolvedDate}.md`);
-        let appended = false;
-        if (existsSync(filePath)) {
-            const existing = await readFile(filePath, "utf-8");
-            const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-            await writeFile(filePath, existing + separator + content + "\n", "utf-8");
-            appended = true;
-        }
-        else {
-            await writeFile(filePath, content + "\n", "utf-8");
+        const results = [];
+        for (const write of writes) {
+            const filePath = join(memoryDir, `${write.date}.md`);
+            let appended = false;
+            if (existsSync(filePath)) {
+                const existing = await readFile(filePath, "utf-8");
+                const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+                await writeFile(filePath, existing + separator + write.content + "\n", "utf-8");
+                appended = true;
+            }
+            else {
+                await writeFile(filePath, write.content + "\n", "utf-8");
+            }
+            results.push({
+                engramId,
+                date: write.date,
+                appended,
+                path: filePath,
+            });
         }
-        return {
-            engramId,
-            date: resolvedDate,
-            appended,
-            path: filePath,
-        };
+        return results;
     }
 }
 export class MemoryWriteEngramNotFoundError extends Error {

package/dist/interfaces/cli/commands/config.js

@@ -142,7 +142,7 @@ export function registerConfigCommand(program) {
     // relic config distillation-batch-size [n]
     config
         .command("distillation-batch-size [n]")
-        .description("Get or set the number of archive entries to distill at once (default: 30)")
+        .description("Get or set the number of archive entries to distill at once (default: 100)")
         .action(async (n) => {
         await ensureInitialized();
         const cfg = await loadConfig();

package/dist/interfaces/mcp/index.js

@@ -3,8 +3,8 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import { ArchiveSearch, ArchiveSearchEngramNotFoundError, } from "../../core/usecases/archive-search.js";
-import { ArchivePending, ArchivePendingEngramNotFoundError, } from "../../core/usecases/archive-pending.js";
-import { ArchiveCursorUpdate, } from "../../core/usecases/archive-cursor-update.js";
+import { ArchivePending, ArchiveCursorCorruptedError, ArchivePendingEngramNotFoundError, } from "../../core/usecases/archive-pending.js";
+import { ArchiveCursorUpdate, ArchiveCursorAdvanceOverflowError, } from "../../core/usecases/archive-cursor-update.js";
 import { MemoryWrite, MemoryWriteEngramNotFoundError, } from "../../core/usecases/memory-write.js";
 import { CreateEngram, EngramAlreadyExistsError, InvalidEngramIdError, } from "../../core/usecases/create-engram.js";
 import { DEFAULT_SOUL, DEFAULT_IDENTITY } from "../../shared/templates.js";
@@ -13,6 +13,63 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 import { resolveDistillationBatchSize, resolveEngramsPath, } from "../../shared/config.js";
+async function appendLongTermAndUserProfile(engramsPath, id, long_term, user_profile) {
+    let longTermWritten = false;
+    if (long_term) {
+        const memoryMdPath = join(engramsPath, id, "MEMORY.md");
+        if (existsSync(memoryMdPath)) {
+            const existing = await readFile(memoryMdPath, "utf-8");
+            const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+            await writeFile(memoryMdPath, existing + separator + long_term + "\n", "utf-8");
+        }
+        else {
+            await writeFile(memoryMdPath, long_term + "\n", "utf-8");
+        }
+        longTermWritten = true;
+    }
+    let userProfileWritten = false;
+    if (user_profile) {
+        const userMdPath = join(engramsPath, id, "USER.md");
+        await writeFile(userMdPath, user_profile + "\n", "utf-8");
+        userProfileWritten = true;
+    }
+    return { longTermWritten, userProfileWritten };
+}
+function assertDateCoverage(writes, expectedDates, skippedDates) {
+    const writeDates = writes.map((write) => write.date);
+    const duplicateWriteDates = findDuplicates(writeDates);
+    if (duplicateWriteDates.length > 0) {
+        throw new Error(`Duplicate write dates are not allowed: ${duplicateWriteDates.join(", ")}`);
+    }
+    const duplicateSkippedDates = findDuplicates(skippedDates);
+    if (duplicateSkippedDates.length > 0) {
+        throw new Error(`Duplicate skipped_dates are not allowed: ${duplicateSkippedDates.join(", ")}`);
+    }
+    const overlappedDates = writeDates.filter((date) => skippedDates.includes(date));
+    if (overlappedDates.length > 0) {
+        throw new Error(`Dates cannot appear in both writes and skipped_dates: ${[...new Set(overlappedDates)].join(", ")}`);
+    }
+    const expectedSet = new Set(expectedDates);
+    const coveredDates = [...writeDates, ...skippedDates];
+    const unexpectedDates = coveredDates.filter((date) => !expectedSet.has(date));
+    if (unexpectedDates.length > 0) {
+        throw new Error(`Unexpected dates: ${[...new Set(unexpectedDates)].join(", ")}`);
+    }
+    const coveredSet = new Set(coveredDates);
+    const missingDates = expectedDates.filter((date) => !coveredSet.has(date));
+    if (missingDates.length > 0) {
+        throw new Error(`Missing dates: ${missingDates.join(", ")}`);
+    }
+}
+function findDuplicates(values) {
+    const counts = new Map();
+    for (const value of values) {
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .filter(([, count]) => count > 1)
+        .map(([value]) => value);
+}
 const server = new McpServer({
     name: "relic",
     version: "0.1.0",
@@ -153,16 +210,34 @@ server.tool("relic_archive_pending", "Get un-distilled archive entries since the
                 ],
             };
         }
-        const header = `cursor: ${result.cursor} | total: ${result.total} | returned: ${result.entries.length} | remaining: ${result.remaining}`;
+        const dates = [...new Set(result.entries.map((entry) => entry.date).filter(Boolean))];
+        const header = [
+            `cursor: ${result.cursor}`,
+            `total: ${result.total}`,
+            `returned: ${result.entries.length}`,
+            `remaining: ${result.remaining}`,
+            `dates: ${dates.length > 0 ? dates.join(", ") : "unknown"}`,
+        ].join(" | ");
         const body = result.entries
-            .map((e, i) => `[entry ${result.cursor + i + 1}]\n${e}`)
+            .map((entry, i) => {
+            const lines = [`[entry ${result.cursor + i + 1}]`];
+            if (entry.date) {
+                lines.push(`date: ${entry.date}`);
+            }
+            if (entry.summary) {
+                lines.push(`summary: ${entry.summary}`);
+            }
+            lines.push(entry.raw);
+            return lines.join("\n");
+        })
             .join("\n\n---\n\n");
         return {
             content: [{ type: "text", text: `${header}\n\n${body}` }],
         };
     }
     catch (err) {
-        if (err instanceof ArchivePendingEngramNotFoundError) {
+        if (err instanceof ArchivePendingEngramNotFoundError ||
+            err instanceof ArchiveCursorCorruptedError) {
             return {
                 content: [{ type: "text", text: err.message }],
                 isError: true,
@@ -174,7 +249,19 @@ server.tool("relic_archive_pending", "Get un-distilled archive entries since the
 // --- relic_memory_write ---
 server.tool("relic_memory_write", "Write distilled memory to an Engram's memory file and advance the archive cursor. Call this after reviewing pending archive entries and distilling them into key insights.", {
     id: z.string().describe("Engram ID"),
-    content: z.string().describe("Distilled memory content to write to memory/YYYY-MM-DD.md"),
+    writes: z
+        .array(z.object({
+        date: z.string().describe("Archive entry date for this memory file (YYYY-MM-DD)"),
+        content: z.string().describe("Distilled memory content for memory/YYYY-MM-DD.md"),
+    }))
+        .min(0)
+        .describe("Distilled memory writes grouped by actual archive dates"),
+    expected_dates: z
+        .array(z.string())
+        .describe("All archive dates that must be explicitly covered by writes or skipped_dates"),
+    skipped_dates: z
+        .array(z.string())
+        .describe("Archive dates intentionally skipped because they produced no durable memory"),
     count: z
         .number()
         .describe("Number of archive entries distilled (from relic_archive_pending returned count)"),
@@ -186,10 +273,6 @@ server.tool("relic_memory_write", "Write distilled memory to an Engram's memory
         .string()
         .optional()
         .describe("User profile updates to write to USER.md (preferences, tendencies, work style — about the human, not the project)"),
-    date: z
-        .string()
-        .optional()
-        .describe("Date for memory file (YYYY-MM-DD, default: today)"),
     path: z
         .string()
         .optional()
@@ -197,36 +280,21 @@ server.tool("relic_memory_write", "Write distilled memory to an Engram's memory
 }, async (args) => {
     const engramsPath = await resolveEngramsPath(args.path);
     try {
-        // Step 1: Write daily memory
         const memoryWrite = new MemoryWrite(engramsPath);
-        const writeResult = await memoryWrite.execute(args.id, args.content, args.date);
-        // Step 2: Append to MEMORY.md if long_term is provided
-        let longTermWritten = false;
-        if (args.long_term) {
-            const memoryMdPath = join(engramsPath, args.id, "MEMORY.md");
-            if (existsSync(memoryMdPath)) {
-                const existing = await readFile(memoryMdPath, "utf-8");
-                const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-                await writeFile(memoryMdPath, existing + separator + args.long_term + "\n", "utf-8");
-            }
-            else {
-                await writeFile(memoryMdPath, args.long_term + "\n", "utf-8");
-            }
-            longTermWritten = true;
-        }
-        // Step 2.5: Write USER.md if user_profile is provided
-        let userProfileWritten = false;
-        if (args.user_profile) {
-            const userMdPath = join(engramsPath, args.id, "USER.md");
-            await writeFile(userMdPath, args.user_profile + "\n", "utf-8");
-            userProfileWritten = true;
-        }
-        // Step 3: Advance cursor by the number of distilled entries
+        assertDateCoverage(args.writes, args.expected_dates, args.skipped_dates);
+        const writeResults = await memoryWrite.executeBatch(args.id, args.writes);
+        const writeSummary = writeResults.length > 0
+            ? writeResults
+                .map((result) => `${result.date} (${result.appended ? "appended" : "created"})`)
+                .join(", ")
+            : "no files";
+        const { longTermWritten, userProfileWritten } = await appendLongTermAndUserProfile(engramsPath, args.id, args.long_term, args.user_profile);
         const cursorUpdate = new ArchiveCursorUpdate(engramsPath);
         const cursorResult = await cursorUpdate.execute(args.id, args.count);
-        const parts = [
-            `Memory written to ${writeResult.date} (${writeResult.appended ? "appended" : "created"}).`,
-        ];
+        const parts = [`Memory written to ${writeSummary}.`];
+        if (args.skipped_dates.length > 0) {
+            parts.push(`Skipped dates: ${args.skipped_dates.join(", ")}.`);
+        }
         if (longTermWritten) {
             parts.push("Long-term memory (MEMORY.md) updated.");
         }
@@ -244,7 +312,10 @@ server.tool("relic_memory_write", "Write distilled memory to an Engram's memory
         };
     }
     catch (err) {
-        if (err instanceof MemoryWriteEngramNotFoundError) {
+        if (err instanceof MemoryWriteEngramNotFoundError ||
+            err instanceof ArchiveCursorAdvanceOverflowError ||
+            err instanceof ArchiveCursorCorruptedError ||
+            err instanceof Error) {
             return {
                 content: [{ type: "text", text: err.message }],
                 isError: true,

package/dist/shared/config.d.ts

@@ -17,7 +17,7 @@ export declare const RelicConfigSchema: z.ZodObject<{
     clawPath: z.ZodOptional<z.ZodString>;
     /** システムプロンプトに含める直近メモリエントリ数 (default: 2) */
     memoryWindowSize: z.ZodDefault<z.ZodNumber>;
-    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 30) */
+    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 100) */
     distillationBatchSize: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     memoryWindowSize: number;
@@ -80,7 +80,7 @@ export declare function resolveClawPath(cliOverride?: string): Promise<string |
 export declare function resolveMemoryWindowSize(): Promise<number>;
 /**
  * 記憶蒸留のバッチ件数を解決する。
- * 優先順位: config.distillationBatchSize > 30 (デフォルト)
+ * 優先順位: config.distillationBatchSize > 100 (デフォルト)
  */
 export declare function resolveDistillationBatchSize(): Promise<number>;
 /**

package/dist/shared/config.js

@@ -24,8 +24,8 @@ export const RelicConfigSchema = z.object({
     clawPath: z.string().optional(),
     /** システムプロンプトに含める直近メモリエントリ数 (default: 2) */
     memoryWindowSize: z.number().int().min(1).default(2),
-    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 30) */
-    distillationBatchSize: z.number().int().min(1).default(30),
+    /** 一度の記憶蒸留で扱う archive エントリ数 (default: 100) */
+    distillationBatchSize: z.number().int().min(1).default(100),
 });
 /**
  * 設定ファイルを読み込む。存在しなければデフォルト値を返す。
@@ -163,7 +163,7 @@ export async function resolveMemoryWindowSize() {
 }
 /**
  * 記憶蒸留のバッチ件数を解決する。
- * 優先順位: config.distillationBatchSize > 30 (デフォルト)
+ * 優先順位: config.distillationBatchSize > 100 (デフォルト)
  */
 export async function resolveDistillationBatchSize() {
     await ensureInitialized();

package/dist/shared/engram-composer.d.ts

@@ -9,7 +9,7 @@ export interface ComposeOptions {
     currentDate?: string;
     /** システムプロンプトに含める直近メモリエントリ数（デフォルト: 2） */
     memoryWindowSize?: number;
-    /** 一度の記憶蒸留で扱う archive エントリ数（デフォルト: 30） */
+    /** 一度の記憶蒸留で扱う archive エントリ数（デフォルト: 100） */
     distillationBatchSize?: number;
 }
 /**

package/dist/shared/engram-composer.js

@@ -46,7 +46,7 @@ export function composeEngram(files, options) {
  */
 function composeRelicSection(meta, distillationBatchSize, currentDate) {
     const today = currentDate ?? new Date().toISOString().split("T")[0];
-    const batchSize = distillationBatchSize ?? 30;
+    const batchSize = distillationBatchSize ?? 100;
     return `# Relic System
 
 - engramId: ${meta.id}
@@ -68,16 +68,20 @@ To recall past context, use \`relic_archive_search\` to search your archive by k
 
 When the user asks you to organize or distill memories:
 1. Call \`relic_archive_pending\` **once** to get un-distilled session entries (up to ${batchSize})
-2. Review and distill them into:
-   - **content**: key facts, decisions, and insights for \`memory/YYYY-MM-DD.md\`
+2. Review the archive entry dates and group the distilled memory by the **actual archive entry date**, not the distillation date
+3. Distill them into:
+   - **writes**: one item per date, each with \`date\` and \`content\`, for \`memory/YYYY-MM-DD.md\`
+   - **expected_dates**: every archive date present in the pending batch
+   - **skipped_dates**: dates that had pending entries but produced no durable memory worth saving
    - **long_term** (optional): only the most important, enduring facts for \`MEMORY.md\` (e.g. project architecture decisions, key constraints, hard rules)
    - **user_profile** (optional): full updated user profile for \`USER.md\` (preferences, tendencies, work style — about the human, not the project)
-3. Call \`relic_memory_write\` with \`content\`, \`count\`, and optionally \`long_term\` and/or \`user_profile\`
-4. If \`remaining > 0\`, inform the user how many entries are still pending — do NOT fetch more automatically
+4. Call \`relic_memory_write\` with \`writes\`, \`expected_dates\`, \`skipped_dates\`, \`count\`, and optionally \`long_term\` and/or \`user_profile\`
+5. If \`remaining > 0\`, inform the user how many entries are still pending — do NOT fetch more automatically
 
 **Important:**
 - Write distilled memories in the **same language the user is using** in the current conversation
 - Do NOT loop or repeat the distillation process — one round per user request
+- Every archive date in the pending batch must appear in exactly one of \`writes.date\` or \`skipped_dates\`
 - \`long_term\` should be highly selective — only facts that matter across all future sessions (objective facts and rules)
 - \`user_profile\` is a complete replacement, not an append — write the full profile each time you update it (user tendencies, preferences, work style)
 - Distilled memories are loaded into your prompt on future sessions`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ectplsm/relic",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "PROJECT RELIC — Engram injection system for AI constructs",
   "license": "MIT",
   "repository": {