@ectplsm/relic 0.4.0 → 0.5.1

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/cli/commands/mikoshi.js

@@ -3,7 +3,7 @@ import { MikoshiApiClient } from "../../../adapters/mikoshi/client.js";
 import { printBlank, printDetail, printErrorDetail, printErrorLine, printLine } from "../output.js";
 import { startSpinner } from "../spinner.js";
 import { MikoshiStatus, MikoshiStatusEngramNotFoundError, MikoshiStatusCloudNotFoundError, } from "../../../core/usecases/mikoshi-status.js";
-import { MikoshiPush, MikoshiPushEngramNotFoundError, MikoshiPushPersonaConflictError, MikoshiPushPersonaHashError, } from "../../../core/usecases/mikoshi-push.js";
+import { MikoshiPush, MikoshiPushEngramNotFoundError, MikoshiPushPersonaConflictError, MikoshiPushPersonaHashError, MikoshiPushAvatarInvalidMimeError, MikoshiPushAvatarHttpError, MikoshiPushAvatarPrivateHostError, MikoshiPushAvatarFetchError, MikoshiPushAvatarReadError, MikoshiPushAvatarTooLargeError, } from "../../../core/usecases/mikoshi-push.js";
 import { MikoshiDownload, MikoshiDownloadAlreadyExistsError, MikoshiDownloadCloudNotFoundError, MikoshiDownloadPersonaMissingError, } from "../../../core/usecases/mikoshi-download.js";
 import { MikoshiPull, MikoshiPullEngramNotFoundError, MikoshiPullCloudNotFoundError, MikoshiPullPersonaMissingError, } from "../../../core/usecases/mikoshi-pull.js";
 import { MikoshiMemorySync, MikoshiMemorySyncEngramNotFoundError, MikoshiMemorySyncCloudNotFoundError, MikoshiMemorySyncDecryptError, } from "../../../core/usecases/mikoshi-memory-sync.js";
@@ -152,33 +152,105 @@ export function registerMikoshiCommand(program) {
             const { result, apply } = await usecase.check(engramId);
             checkSpinner.stop();
             checkSpinner = undefined;
-            if (result.outcome === "already_synced") {
+            const needsAvatarUpload = result.avatar?.outcome === "upload_required";
+            if (!apply) {
+                // already_synced と avatar 変更なし
                 printLine(`✅ Persona already in sync (${result.engramName})`);
+                printAvatarSkipReason(result.avatar);
             }
             else {
-                if (result.outcome === "create_required") {
-                    if (!opts.yes &&
-                        !(await confirm(`Engram "${engramId}" does not exist on Mikoshi. Create it? [y/N] `))) {
+                // Avatar URL drift の情報提示 (Phase 3):
+                // IDENTITY.md の diff が Avatar 行の値だけなら、ユーザーが
+                // 「自分は変更してないのに push_required と言われる」状態を
+                // 把握できるよう、確認プロンプトの前に理由を説明する。
+                if (result.avatarDrift) {
+                    printErrorLine("⚠ IDENTITY.md differs only in the Avatar line.");
+                    printErrorDetail(`local:  ${result.avatarDrift.localValue}`);
+                    printErrorDetail(`remote: ${result.avatarDrift.remoteValue}`);
+                    printErrorLine("  This typically happens after 'relic mikoshi pull' rewrote the Avatar line to the R2 URL.");
+                    printErrorLine("  Pushing will overwrite the remote IDENTITY.md with the local version.");
+                    printBlank();
+                }
+                // Persona 確認 (already_synced のときは avatar-only なので persona 確認はスキップ)
+                if (result.outcome !== "already_synced" && !opts.yes) {
+                    const prompt = result.avatarDrift
+                        ? `Push the Avatar URL change to Mikoshi for "${engramId}"? [y/N] `
+                        : result.outcome === "create_required"
+                            ? `Engram "${engramId}" does not exist on Mikoshi. Create it? [y/N] `
+                            : `Overwrite Mikoshi persona with the local Relic version for "${engramId}"? [y/N] `;
+                    if (!(await confirm(prompt))) {
                         printLine("Skipped.");
                         return;
                     }
                 }
-                else if (!opts.yes &&
-                    !(await confirm(`Overwrite Mikoshi persona with the local Relic version for "${engramId}"? [y/N] `))) {
-                    printLine("Skipped.");
-                    return;
+                // Avatar 確認
+                if (needsAvatarUpload && !opts.yes) {
+                    const av = result.avatar;
+                    printLine(`Avatar to upload for "${engramId}":`);
+                    if (av.source === "url" && av.sourceUrl) {
+                        printDetail(`url: ${av.sourceUrl}`);
+                    }
+                    if (av.localPath)
+                        printDetail(`path: ${av.localPath}`);
+                    if (av.localMimeType)
+                        printDetail(`mime: ${av.localMimeType}`);
+                    if (av.localSize !== undefined)
+                        printDetail(`size: ${formatBytes(av.localSize)}`);
+                    if (av.localHash)
+                        printDetail(`hash: ${av.localHash}`);
+                    if (!(await confirm(`Upload this avatar? [y/N] `))) {
+                        printLine("Skipped.");
+                        return;
+                    }
                 }
-                applySpinner = startSpinner("Pushing persona to Mikoshi...");
-                const applied = await apply();
+                const spinnerMessage = result.outcome === "already_synced"
+                    ? result.avatar?.source === "url"
+                        ? "Fetching avatar from URL and uploading to Mikoshi..."
+                        : "Uploading avatar to Mikoshi..."
+                    : result.avatar?.source === "url" && result.avatar?.outcome === "upload_required"
+                        ? "Pushing persona, then fetching avatar from URL..."
+                        : "Pushing persona to Mikoshi...";
+                applySpinner = startSpinner(spinnerMessage);
+                const applied = await apply({
+                    onAvatarProgress: (stage) => {
+                        if (!applySpinner)
+                            return;
+                        if (stage === "fetching") {
+                            applySpinner.update("Fetching avatar from URL...");
+                            return;
+                        }
+                        applySpinner.update("Uploading avatar to Mikoshi...");
+                    },
+                });
                 if (applied.action === "created") {
                     applySpinner.stop(`✅ Created "${result.engramName}" on Mikoshi.`);
                     applySpinner = undefined;
                     printLine(`Cloud ID: ${applied.cloudEngramId}`);
                 }
-                else {
+                else if (applied.action === "updated") {
                     applySpinner.stop(`✅ Persona updated for "${result.engramName}".`);
                     applySpinner = undefined;
-                    printLine(`Hash: ${applied.newPersonaHash}`);
+                    if (applied.newPersonaHash)
+                        printLine(`Hash: ${applied.newPersonaHash}`);
+                }
+                else {
+                    // avatar_only
+                    applySpinner.stop(`✅ Avatar updated for "${result.engramName}".`);
+                    applySpinner = undefined;
+                }
+                // Avatar の結果を最後に報告
+                if (applied.avatarAction === "uploaded" && applied.newAvatarUrl) {
+                    printLine(`Avatar: ${applied.newAvatarUrl}`);
+                }
+                else if (applied.avatarAction === "skipped" && applied.avatarSkipReason) {
+                    printAvatarSkipReason({ outcome: "skip", skipReason: applied.avatarSkipReason });
+                }
+                else if (applied.avatarAction === "failed") {
+                    const failureLabel = applied.avatarFailureStage === "fetch"
+                        ? "Avatar fetch failed"
+                        : "Avatar upload failed";
+                    printErrorLine(`⚠ ${failureLabel}: ${applied.avatarError?.message ?? "unknown error"}`);
+                    printErrorLine("  The persona change was saved. Retry with 'relic mikoshi push' to upload the avatar.");
                 }
             }
         }
@@ -202,6 +274,43 @@ export function registerMikoshiCommand(program) {
                 printErrorLine("Re-run 'relic mikoshi status' to review the current state.");
                 process.exit(1);
             }
+            if (err instanceof MikoshiPushAvatarInvalidMimeError) {
+                printError(`Error: Avatar format is not supported.`);
+                printErrorDetail(`Source: ${err.avatarPath}`);
+                printErrorDetail("Allowed: JPEG, PNG, WebP");
+                process.exit(1);
+            }
+            if (err instanceof MikoshiPushAvatarTooLargeError) {
+                printError(`Error: Avatar exceeds ${formatBytes(err.maxBytes)} (actual: ${formatBytes(err.actualBytes)}).`);
+                printErrorDetail(`Source: ${err.avatarPath}`);
+                process.exit(1);
+            }
+            if (err instanceof MikoshiPushAvatarReadError) {
+                printError(`Error: Failed to read avatar file.`);
+                printErrorDetail(`Path: ${err.avatarPath}`);
+                if (err.cause instanceof Error) {
+                    printErrorDetail(err.cause.message);
+                }
+                process.exit(1);
+            }
+            if (err instanceof MikoshiPushAvatarHttpError) {
+                printError("Error: Avatar URL must use HTTPS.");
+                printErrorDetail(`URL: ${err.avatarUrl}`);
+                process.exit(1);
+            }
+            if (err instanceof MikoshiPushAvatarPrivateHostError) {
+                printError("Error: Avatar URL points to a private host.");
+                printErrorDetail(`URL: ${err.avatarUrl}`);
+                process.exit(1);
+            }
+            if (err instanceof MikoshiPushAvatarFetchError) {
+                printError("Error: Failed to fetch avatar from URL.");
+                printErrorDetail(`URL: ${err.avatarUrl}`);
+                if (err.cause instanceof Error) {
+                    printErrorDetail(err.cause.message);
+                }
+                process.exit(1);
+            }
             if (err instanceof MikoshiApiError) {
                 handleMikoshiApiError(err);
             }
@@ -250,6 +359,9 @@ export function registerMikoshiCommand(program) {
                 const result = await download.execute(engramId);
                 applySpinner.stop(`✅ Pulled "${result.engramName}" from Mikoshi.`);
                 applySpinner = undefined;
+                if (result.rewrittenAvatarUrl) {
+                    printDetail(`Avatar line rewritten to Mikoshi URL: ${result.rewrittenAvatarUrl}`);
+                }
                 if (opts.sync) {
                     const passphrase = await resolvePassphraseForSync();
                     const syncUsecase = new MikoshiMemorySync(repo, client);
@@ -278,6 +390,9 @@ export function registerMikoshiCommand(program) {
                 printDetail("SOUL.md     — differs");
             if (diff.identityDiffers)
                 printDetail("IDENTITY.md — differs");
+            if (diff.rewrittenAvatarUrl) {
+                printDetail(`Avatar line will be rewritten to Mikoshi URL: ${diff.rewrittenAvatarUrl}`);
+            }
             printBlank();
             // 確認プロンプト
             if (!opts.yes) {
@@ -415,6 +530,21 @@ export function registerMikoshiCommand(program) {
         }
     });
 }
+function printAvatarSkipReason(avatar) {
+    if (!avatar || avatar.outcome !== "skip" || !avatar.skipReason)
+        return;
+    switch (avatar.skipReason) {
+        case "remote_avatar_url_matches_identity":
+            printLine("Avatar upload skipped: remote avatar URL already matches the local Avatar field.");
+            return;
+        case "source_url_unchanged":
+            printLine("Avatar upload skipped: avatar source URL is unchanged from the last successful push.");
+            return;
+        case "local_file_hash_unchanged":
+            printLine("Avatar upload skipped: local avatar file hash matches the last successful push.");
+            return;
+    }
+}
 // ---------------------------------------------------------------------------
 // Shared error handler
 // ---------------------------------------------------------------------------
@@ -457,6 +587,13 @@ function statusLabel(status) {
         default: return status;
     }
 }
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
 function confirm(prompt) {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {

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.1",
   "description": "PROJECT RELIC — Engram injection system for AI constructs",
   "license": "MIT",
   "repository": {