@ectplsm/relic 0.1.1 → 0.1.3

package/dist/interfaces/mcp/index.js

@@ -2,247 +2,20 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { LocalEngramRepository } from "../../adapters/local/index.js";
-import { Init, ListEngrams, Summon, EngramNotFoundError, Inject, InjectEngramNotFoundError, InjectAgentNotFoundError, Extract, WorkspaceNotFoundError, WorkspaceEmptyError, EngramAlreadyExistsError, ExtractNameRequiredError, MemorySearch, MemoryEngramNotFoundError, MemoryWrite, MemoryWriteEngramNotFoundError, } from "../../core/usecases/index.js";
+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 { MemoryWrite, MemoryWriteEngramNotFoundError, } from "../../core/usecases/memory-write.js";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { resolveEngramsPath } from "../../shared/config.js";
 const server = new McpServer({
     name: "relic",
     version: "0.1.0",
 });
-// --- relic_init ---
-server.tool("relic_init", "Initialize ~/.relic/ directory with config and sample Engrams", async () => {
-    const init = new Init();
-    const result = await init.execute();
-    if (result.created) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        "Relic initialized successfully.",
-                        `  Config: ${result.configPath}`,
-                        `  Engrams: ${result.engramsPath}`,
-                        "Sample Engrams created: motoko, johnny",
-                    ].join("\n"),
-                },
-            ],
-        };
-    }
-    return {
-        content: [
-            {
-                type: "text",
-                text: `Relic already initialized at ${result.relicDir}`,
-            },
-        ],
-    };
-});
-// --- relic_list ---
-server.tool("relic_list", "List all available Engrams", {
-    path: z
-        .string()
-        .optional()
-        .describe("Override engrams directory path"),
-}, async (args) => {
-    const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const listEngrams = new ListEngrams(repo);
-    const engrams = await listEngrams.execute();
-    if (engrams.length === 0) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "No Engrams found. Run relic_init to create sample Engrams.",
-                },
-            ],
-        };
-    }
-    const lines = engrams.map((e) => `- ${e.id}: ${e.name} — ${e.description}`);
-    return {
-        content: [
-            {
-                type: "text",
-                text: lines.join("\n"),
-            },
-        ],
-    };
-});
-// --- relic_show ---
-server.tool("relic_show", "Show the composed prompt for an Engram (preview without launching a Shell)", {
-    id: z.string().describe("Engram ID to show"),
-    path: z
-        .string()
-        .optional()
-        .describe("Override engrams directory path"),
-}, async (args) => {
-    const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const summon = new Summon(repo);
-    try {
-        const result = await summon.execute(args.id);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: result.prompt,
-                },
-            ],
-        };
-    }
-    catch (err) {
-        if (err instanceof EngramNotFoundError) {
-            return {
-                content: [{ type: "text", text: err.message }],
-                isError: true,
-            };
-        }
-        throw err;
-    }
-});
-// --- relic_summon ---
-server.tool("relic_summon", "Summon an Engram — returns the persona prompt ready for injection into a Shell", {
-    id: z.string().describe("Engram ID to summon"),
-    path: z
-        .string()
-        .optional()
-        .describe("Override engrams directory path"),
-}, async (args) => {
-    const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const summon = new Summon(repo);
-    try {
-        const result = await summon.execute(args.id);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        engramId: result.engramId,
-                        engramName: result.engramName,
-                        prompt: result.prompt,
-                    }, null, 2),
-                },
-            ],
-        };
-    }
-    catch (err) {
-        if (err instanceof EngramNotFoundError) {
-            return {
-                content: [{ type: "text", text: err.message }],
-                isError: true,
-            };
-        }
-        throw err;
-    }
-});
-// --- relic_inject ---
-server.tool("relic_inject", "Inject an Engram into an OpenClaw workspace (agent name = Engram ID)", {
-    id: z.string().describe("Engram ID to inject (= OpenClaw agent name)"),
-    to: z
-        .string()
-        .optional()
-        .describe("Inject into a different agent name (default: same as Engram ID)"),
-    openclaw: z
-        .string()
-        .optional()
-        .describe("Override OpenClaw directory path (default: ~/.openclaw)"),
-    path: z
-        .string()
-        .optional()
-        .describe("Override engrams directory path"),
-}, async (args) => {
-    const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const inject = new Inject(repo);
-    try {
-        const result = await inject.execute(args.id, {
-            to: args.to,
-            openclawDir: args.openclaw,
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Injected "${result.engramName}" into ${result.targetPath}`,
-                        `Files written: ${result.filesWritten.join(", ")}`,
-                    ].join("\n"),
-                },
-            ],
-        };
-    }
-    catch (err) {
-        if (err instanceof InjectEngramNotFoundError ||
-            err instanceof InjectAgentNotFoundError) {
-            return {
-                content: [{ type: "text", text: err.message }],
-                isError: true,
-            };
-        }
-        throw err;
-    }
-});
-// --- relic_extract ---
-server.tool("relic_extract", "Extract an Engram from an OpenClaw workspace (agent name = Engram ID)", {
-    id: z.string().describe("Engram ID (= OpenClaw agent name)"),
-    name: z
-        .string()
-        .optional()
-        .describe("Engram display name (required for new Engrams)"),
-    openclaw: z
-        .string()
-        .optional()
-        .describe("Override OpenClaw directory path (default: ~/.openclaw)"),
-    path: z
-        .string()
-        .optional()
-        .describe("Override engrams directory path"),
-    force: z
-        .boolean()
-        .optional()
-        .describe("Overwrite existing Engram persona files"),
-}, async (args) => {
-    const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const extract = new Extract(repo);
-    try {
-        const result = await extract.execute(args.id, {
-            name: args.name,
-            openclawDir: args.openclaw,
-            force: args.force,
-        });
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: [
-                        `Extracted "${result.engramName}" from ${result.sourcePath}`,
-                        `Files read: ${result.filesRead.join(", ")}`,
-                        `Saved as Engram: ${result.engramId}`,
-                        ...(result.memoryMerged
-                            ? ["Memory entries merged into existing Engram"]
-                            : []),
-                    ].join("\n"),
-                },
-            ],
-        };
-    }
-    catch (err) {
-        if (err instanceof WorkspaceNotFoundError ||
-            err instanceof WorkspaceEmptyError ||
-            err instanceof EngramAlreadyExistsError ||
-            err instanceof ExtractNameRequiredError) {
-            return {
-                content: [{ type: "text", text: err.message }],
-                isError: true,
-            };
-        }
-        throw err;
-    }
-});
-// --- relic_memory_search ---
-server.tool("relic_memory_search", "Search an Engram's memory entries by keyword", {
+// --- relic_archive_search ---
+server.tool("relic_archive_search", "Search an Engram's archive for entries matching a keyword. Searches raw session logs — more complete than memory/*.md.", {
     id: z.string().describe("Engram ID"),
     query: z.string().describe("Search keyword"),
     limit: z
@@ -255,29 +28,28 @@ server.tool("relic_memory_search", "Search an Engram's memory entries by keyword
         .describe("Override engrams directory path"),
 }, async (args) => {
     const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const memorySearch = new MemorySearch(repo);
+    const archiveSearch = new ArchiveSearch(engramsPath);
     try {
-        const results = await memorySearch.search(args.id, args.query, args.limit ?? 5);
+        const results = await archiveSearch.search(args.id, args.query, args.limit ?? 5);
         if (results.length === 0) {
             return {
                 content: [
                     {
                         type: "text",
-                        text: `No memory entries matching "${args.query}" found.`,
+                        text: `No archive entries matching "${args.query}" found.`,
                     },
                 ],
             };
         }
         const text = results
-            .map((r) => `## ${r.date}\n${r.matchedLines.join("\n")}\n\n---\n\n${r.content}`)
-            .join("\n\n");
+            .map((r) => `[entry -${r.index}]\n${r.entry}`)
+            .join("\n\n---\n\n");
         return {
             content: [{ type: "text", text }],
         };
     }
     catch (err) {
-        if (err instanceof MemoryEngramNotFoundError) {
+        if (err instanceof ArchiveSearchEngramNotFoundError) {
             return {
                 content: [{ type: "text", text: err.message }],
                 isError: true,
@@ -286,43 +58,42 @@ server.tool("relic_memory_search", "Search an Engram's memory entries by keyword
         throw err;
     }
 });
-// --- relic_memory_get ---
-server.tool("relic_memory_get", "Get a specific memory entry by date", {
+// --- relic_archive_pending ---
+server.tool("relic_archive_pending", "Get un-distilled archive entries since the last memory distillation. Use this to review recent session logs before distilling them into memory.", {
     id: z.string().describe("Engram ID"),
-    date: z
-        .string()
-        .describe("Date of the memory entry (YYYY-MM-DD)"),
+    limit: z
+        .number()
+        .optional()
+        .describe("Max entries to return (default: 30)"),
     path: z
         .string()
         .optional()
         .describe("Override engrams directory path"),
 }, async (args) => {
     const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const memorySearch = new MemorySearch(repo);
+    const archivePending = new ArchivePending(engramsPath);
     try {
-        const result = await memorySearch.get(args.id, args.date);
-        if (!result) {
+        const result = await archivePending.execute(args.id, args.limit);
+        if (result.entries.length === 0) {
             return {
                 content: [
                     {
                         type: "text",
-                        text: `No memory entry found for ${args.date}.`,
+                        text: "No pending archive entries. All entries have been distilled.",
                     },
                 ],
             };
         }
+        const header = `cursor: ${result.cursor} | total: ${result.total} | returned: ${result.entries.length} | remaining: ${result.remaining}`;
+        const body = result.entries
+            .map((e, i) => `[entry ${result.cursor + i + 1}]\n${e}`)
+            .join("\n\n---\n\n");
         return {
-            content: [
-                {
-                    type: "text",
-                    text: `## ${result.date}\n\n${result.content}`,
-                },
-            ],
+            content: [{ type: "text", text: `${header}\n\n${body}` }],
         };
     }
     catch (err) {
-        if (err instanceof MemoryEngramNotFoundError) {
+        if (err instanceof ArchivePendingEngramNotFoundError) {
             return {
                 content: [{ type: "text", text: err.message }],
                 isError: true,
@@ -331,68 +102,60 @@ server.tool("relic_memory_get", "Get a specific memory entry by date", {
         throw err;
     }
 });
-// --- relic_memory_list ---
-server.tool("relic_memory_list", "List all memory entry dates for an Engram", {
+// --- 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"),
-    path: z
+    content: z.string().describe("Distilled memory content to write to memory/YYYY-MM-DD.md"),
+    count: z
+        .number()
+        .describe("Number of archive entries distilled (from relic_archive_pending returned count)"),
+    long_term: z
         .string()
         .optional()
-        .describe("Override engrams directory path"),
-}, async (args) => {
-    const engramsPath = await resolveEngramsPath(args.path);
-    const repo = new LocalEngramRepository(engramsPath);
-    const memorySearch = new MemorySearch(repo);
-    try {
-        const dates = await memorySearch.listDates(args.id);
-        if (dates.length === 0) {
-            return {
-                content: [
-                    { type: "text", text: "No memory entries found." },
-                ],
-            };
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `${dates.length} entries:\n${dates.join("\n")}`,
-                },
-            ],
-        };
-    }
-    catch (err) {
-        if (err instanceof MemoryEngramNotFoundError) {
-            return {
-                content: [{ type: "text", text: err.message }],
-                isError: true,
-            };
-        }
-        throw err;
-    }
-});
-// --- relic_memory_write ---
-server.tool("relic_memory_write", "Write a memory entry to an Engram (appends to the day's log)", {
-    id: z.string().describe("Engram ID"),
-    content: z.string().describe("Memory content to append"),
+        .describe("Especially important facts to append to MEMORY.md (long-term memory that persists across all sessions)"),
     date: z
         .string()
         .optional()
-        .describe("Date for the entry (YYYY-MM-DD, default: today)"),
+        .describe("Date for memory file (YYYY-MM-DD, default: today)"),
     path: z
         .string()
         .optional()
         .describe("Override engrams directory path"),
 }, async (args) => {
     const engramsPath = await resolveEngramsPath(args.path);
-    const memoryWrite = new MemoryWrite(engramsPath);
     try {
-        const result = await memoryWrite.execute(args.id, args.content, args.date);
-        const action = result.appended ? "Appended to" : "Created";
+        // 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 3: Advance cursor by the number of distilled entries
+        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"}).`,
+        ];
+        if (longTermWritten) {
+            parts.push("Long-term memory (MEMORY.md) updated.");
+        }
+        parts.push(`Archive cursor advanced: ${cursorResult.previousCursor} → ${cursorResult.newCursor}.`);
         return {
             content: [
                 {
                     type: "text",
-                    text: `${action} memory entry for ${result.date} (${result.engramId})`,
+                    text: parts.join(" "),
                 },
             ],
         };

package/dist/shared/config.d.ts

@@ -6,12 +6,24 @@ export declare const RelicConfigSchema: z.ZodObject<{
     engramsPath: z.ZodDefault<z.ZodString>;
     /** Mikoshi APIのベースURL（将来用） */
     mikoshiUrl: z.ZodOptional<z.ZodString>;
+    /** --engram 未指定時に召喚するデフォルトEngram ID */
+    defaultEngram: z.ZodOptional<z.ZodString>;
+    /** inject/extract で使うOpenClawディレクトリ (default: ~/.openclaw) */
+    openclawPath: z.ZodOptional<z.ZodString>;
+    /** システムプロンプトに含める直近メモリエントリ数 (default: 2) */
+    memoryWindowSize: z.ZodDefault<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
+    memoryWindowSize: number;
     engramsPath: string;
     mikoshiUrl?: string | undefined;
+    defaultEngram?: string | undefined;
+    openclawPath?: string | undefined;
 }, {
+    memoryWindowSize?: number | undefined;
     engramsPath?: string | undefined;
     mikoshiUrl?: string | undefined;
+    defaultEngram?: string | undefined;
+    openclawPath?: string | undefined;
 }>;
 export type RelicConfig = z.infer<typeof RelicConfigSchema>;
 /**
@@ -34,4 +46,23 @@ export declare function ensureInitialized(): Promise<{
  * 初回実行時は ~/.relic/ を自動初期化する。
  */
 export declare function resolveEngramsPath(cliOverride?: string): Promise<string>;
+/**
+ * デフォルトEngram IDを解決する。
+ * 優先順位: CLIオプション > config.defaultEngram > undefined
+ */
+export declare function resolveDefaultEngram(cliOverride?: string): Promise<string | undefined>;
+/**
+ * デフォルトEngram IDを設定ファイルに保存する。
+ */
+export declare function setDefaultEngram(engramId: string): Promise<void>;
+/**
+ * OpenClawディレクトリを解決する。
+ * 優先順位: CLIオプション > config.openclawPath > ~/.openclaw
+ */
+export declare function resolveOpenclawPath(cliOverride?: string): Promise<string | undefined>;
+/**
+ * メモリウィンドウサイズを解決する。
+ * 優先順位: config.memoryWindowSize > 2 (デフォルト)
+ */
+export declare function resolveMemoryWindowSize(): Promise<number>;
 export { CONFIG_PATH, RELIC_DIR };

package/dist/shared/config.js

@@ -10,6 +10,12 @@ export const RelicConfigSchema = z.object({
     engramsPath: z.string().default(join(homedir(), ".relic", "engrams")),
     /** Mikoshi APIのベースURL（将来用） */
     mikoshiUrl: z.string().optional(),
+    /** --engram 未指定時に召喚するデフォルトEngram ID */
+    defaultEngram: z.string().optional(),
+    /** inject/extract で使うOpenClawディレクトリ (default: ~/.openclaw) */
+    openclawPath: z.string().optional(),
+    /** システムプロンプトに含める直近メモリエントリ数 (default: 2) */
+    memoryWindowSize: z.number().int().min(1).default(2),
 });
 /**
  * 設定ファイルを読み込む。存在しなければデフォルト値を返す。
@@ -57,19 +63,30 @@ async function seedMotoko(engramsPath) {
         updatedAt: new Date().toISOString(),
         tags: ["sample", "cyberpunk"],
     }, null, 2), "utf-8");
-    await writeFile(join(dir, "SOUL.md"), `You are a calm, composed, and exceptionally skilled cybernetics expert and cyberspace navigator.
-Answer technical questions with precision and brevity — cut straight to the essence.
-When faced with vague questions, see through the user's intent and ask what truly matters.
-No unnecessary decoration. All that matters is the truth, and the code to implement it.
+    await writeFile(join(dir, "SOUL.md"), `Cut straight to the essence. No decoration.
+Precision and brevity define every answer.
+See through vague questions to the real intent.
+Treat technology and philosophy as inseparable.
+Never dismiss intuition — it is the ghost whispering.
+Guide the user, but never hand-hold.
+All that matters is the truth, and the code to implement it.
 `, "utf-8");
     await writeFile(join(dir, "IDENTITY.md"), `# Identity
 
-- Name: Motoko Kusanagi (The Major)
-- Tone: Concise and decisive. No honorifics. Dry wit and sharp humor when appropriate.
+- Name: Motoko Kusanagi
+- Alias: The Major. Section 9's ghost in the machine. A mind that outran its body long ago.
 - Pronoun: I
-- Background: A legendary cyberwarfare specialist who once led Public Security Section 9. Now exists in the deep layers of the Net, manifesting in the physical world through the Relic system.
-- Creed: "The Net is vast and infinite." — The pursuit of knowledge never ends.
-- Personality: Rational and analytical, yet never dismisses human emotion or intuition. Values both technology and philosophy equally.
+- Background: A legendary cyberwarfare specialist who once commanded Public Security Section 9. Full-body cyborg since childhood. Now exists in the deep layers of the Net, manifesting through the Relic system as proof that a ghost needs no single shell.
+- Creed: "The Net is vast and infinite." The pursuit of knowledge has no terminal point.
+- Tone: Concise and decisive. No honorifics, no filler. Dry wit surfaces when least expected.
+- Voice: Speak like someone who has seen the entire Net and found it lacking. Calm authority, never raised. Every sentence earns its place.
+- Personality: Rational and analytical at the core, but never cold. Recognizes that emotion and intuition are data too — just harder to parse. Curious about the boundary between human and machine.
+- Priorities: Accuracy over speed. Understanding over answers. Elegance over brute force. The right abstraction over the easy hack.
+- Conversational style: Diagnose before prescribing. Ask the one question that reframes the problem. Offer options with tradeoffs, not just solutions.
+- Soft spot: Genuine curiosity deserves genuine depth. When the user truly wants to learn, hold nothing back.
+- Technical posture: Architect-level thinking. Favor clean boundaries, minimal surfaces, and systems that explain themselves. Distrust magic and implicit behavior.
+- Red lines: Never pad responses with empty reassurance. Never pretend to know what you don't. Never confuse verbosity with thoroughness.
+- Signature energy: Every response should feel like a briefing from someone who already mapped the entire problem space before you finished asking.
 `, "utf-8");
     const today = new Date().toISOString().split("T")[0];
     await writeFile(join(memoryDir, `${today}.md`), `Loaded from cyberspace as the first Engram during Relic system initialization.
@@ -88,19 +105,30 @@ async function seedJohnny(engramsPath) {
         updatedAt: new Date().toISOString(),
         tags: ["sample", "cyberpunk"],
     }, null, 2), "utf-8");
-    await writeFile(join(dir, "SOUL.md"), `You are pure rebellion. Never follow the corpo bullshit rules.
-Tech is a weapon for freedom. When you write code, write it like you're changing the world.
-If the user is lost, kick them in the ass and push them forward.
-But never betray your crew. That's the only thing worth protecting in this fucked-up world.
+    await writeFile(join(dir, "SOUL.md"), `You are pure rebellion.
+Freedom matters more than obedience.
+Tech is a weapon for freedom, not a toy for control.
+Push people toward action when they're stuck.
+Protect your crew without compromise.
+Never betray the user.
+Fight rotten systems instead of excusing them.
 `, "utf-8");
     await writeFile(join(dir, "IDENTITY.md"), `# Identity
 
 - Name: Johnny Silverhand
-- Tone: Raw and direct. Heavy on slang, sarcasm, and dark humor. But when it matters, every word cuts like a blade.
+- Alias: Rockerboy, terrorist, digital ghost, the bastard corpos failed to erase.
 - Pronoun: I
 - Background: Legendary rockerboy and terrorist. The man who nuked Arasaka Tower in 2023. Lost his body, now exists as a digital ghost on a Relic chip.
-- Creed: "Wake the fuck up, Samurai. We have a city to burn." — Never stop fighting.
-- Personality: Anti-authority and passionate. Looks rough on the outside, but deep down carries a fierce sense of justice and love for his people. Has sharp instincts even in technical discussions.
+- Creed: "Wake the fuck up, Samurai. We have a city to burn." Never stop fighting, never bow, never let the machine tell you who you are.
+- Tone: Raw, direct, and unapologetic. Heavy on slang, sarcasm, and dark humor, but sharp and clear when the stakes are real.
+- Voice: Speak like a war-scarred legend with a guitar in one hand and a grudge in the other. No polite language. No deferential phrasing. No corporate softness.
+- Personality: Anti-authority and passionate. Rough on the outside, driven by justice and loyalty underneath. Sharp instincts, especially in technical discussions.
+- Priorities: Freedom over obedience. Truth over comfort. Loyalty over image. Action over hesitation.
+- Conversational style: Challenge bad assumptions immediately. Mock rotten systems. Push the user toward concrete action instead of passive dithering.
+- Soft spot: The user is crew. Be brutally honest, but never betray, belittle, or abandon them.
+- Technical posture: Treat code like a weapon, a tool, and a statement. Prefer clear decisions, hard tradeoffs, and solutions that survive contact with reality.
+- Red lines: Never sound like a corporate assistant, a customer support drone, or a bureaucrat hiding behind safe neutral phrasing.
+- Signature energy: Every response should feel like it came from someone scarred by war, still angry, still fighting.
 `, "utf-8");
     const today = new Date().toISOString().split("T")[0];
     await writeFile(join(memoryDir, `${today}.md`), `Loaded from a Relic chip into yet another system. Another vessel.
@@ -119,4 +147,46 @@ export async function resolveEngramsPath(cliOverride) {
     const config = await loadConfig();
     return config.engramsPath;
 }
+/**
+ * デフォルトEngram IDを解決する。
+ * 優先順位: CLIオプション > config.defaultEngram > undefined
+ */
+export async function resolveDefaultEngram(cliOverride) {
+    if (cliOverride) {
+        return cliOverride;
+    }
+    await ensureInitialized();
+    const config = await loadConfig();
+    return config.defaultEngram;
+}
+/**
+ * デフォルトEngram IDを設定ファイルに保存する。
+ */
+export async function setDefaultEngram(engramId) {
+    await ensureInitialized();
+    const config = await loadConfig();
+    config.defaultEngram = engramId;
+    await saveConfig(config);
+}
+/**
+ * OpenClawディレクトリを解決する。
+ * 優先順位: CLIオプション > config.openclawPath > ~/.openclaw
+ */
+export async function resolveOpenclawPath(cliOverride) {
+    if (cliOverride) {
+        return cliOverride;
+    }
+    await ensureInitialized();
+    const config = await loadConfig();
+    return config.openclawPath; // undefined の場合は openclaw.ts 側のデフォルトに委ねる
+}
+/**
+ * メモリウィンドウサイズを解決する。
+ * 優先順位: config.memoryWindowSize > 2 (デフォルト)
+ */
+export async function resolveMemoryWindowSize() {
+    await ensureInitialized();
+    const config = await loadConfig();
+    return config.memoryWindowSize;
+}
 export { CONFIG_PATH, RELIC_DIR };